MIDI branch becomes trunk

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

1085 files changed, 27004 insertions, 63350 deletions

diff --git a/libs/.cvsignore b/libs/.cvsignore
new file mode 100644
index 0000000000..e43b0f9889
--- /dev/null
+++ b/libs/.cvsignore
@@ -0,0 +1 @@
+.DS_Store
diff --git a/libs/ardour/SConscript b/libs/ardour/SConscript
index 4eb50bdc54..772f847400 100644
--- a/libs/ardour/SConscript
+++ b/libs/ardour/SConscript
@@ -17,7 +17,6 @@ domain = 'libardour'
 ardour.Append(DOMAIN = domain, MAJOR = 2, MINOR = 0, MICRO = 0)
 ardour.Append(CXXFLAGS = "-DPACKAGE=\\\"" + domain + "\\\"")
 ardour.Append(CXXFLAGS="-DLIBSIGC_DISABLE_DEPRECATED")
-ardour.Append(CXXFLAGS="-DGLIBMM_DISABLE_DEPRECATED")
 ardour.Append(PACKAGE = domain)
 ardour.Append(POTFILE = domain + '.pot')
 
@@ -28,17 +27,33 @@ ardour.Append(POTFILE = domain + '.pot')
 ardour.Append(CPPPATH = '#libs/surfaces/control_protocol')
 
 ardour_files=Split("""
+chan_count.cc
 diskstream.cc
+track.cc
 audio_diskstream.cc
 audio_library.cc
 audio_playlist.cc
-track.cc
 audio_track.cc
 audioengine.cc
+port.cc
+audio_port.cc
+midi_port.cc
+port_set.cc
+buffer.cc
+buffer_set.cc
+meter.cc
+amp.cc
+panner.cc
 audiofilesource.cc
 audiofilter.cc
 audioregion.cc
 audiosource.cc
+midi_source.cc
+midi_diskstream.cc
+midi_playlist.cc
+midi_track.cc
+midi_region.cc
+smf_source.cc
 auditioner.cc
 automation.cc
 automation_event.cc
@@ -61,13 +76,11 @@ ladspa_plugin.cc
 location.cc
 mtc_slave.cc
 named_selection.cc
-panner.cc
 pcm_utils.cc
 playlist.cc
 playlist_factory.cc
 plugin.cc
 plugin_manager.cc
-port.cc
 recent_sessions.cc
 redirect.cc
 region.cc
diff --git a/libs/ardour/amp.cc b/libs/ardour/amp.cc
new file mode 100644
index 0000000000..c437b53243
--- /dev/null
+++ b/libs/ardour/amp.cc
@@ -0,0 +1,102 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <ardour/amp.h>
+
+#include <algorithm>
+#include <cmath>
+#include <ardour/buffer_set.h>
+#include <ardour/buffer.h>
+
+namespace ARDOUR {
+
+
+/** Apply a declicked gain to the audio buffers of @a bufs */
+void
+Amp::run (BufferSet& bufs, nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity)
+{
+	if (nframes == 0)
+		return;
+
+	if (bufs.count().get(DataType::AUDIO) == 0)
+		return;
+
+	// assert(bufs.buffer_capacity(DataType::AUDIO) >= nframes);
+
+	// if we don't need to declick, defer to apply_simple_gain
+	if (initial == target) {
+		if (target == 0.0) {
+			for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+				memset (i->data(), 0, sizeof (Sample) * nframes);
+			}
+		} else if (target != 1.0) {
+			for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+				apply_gain_to_buffer (i->data(), nframes, target);
+			}
+		}
+		return;
+	}
+
+	const nframes_t declick = std::min ((nframes_t)128, nframes);
+	gain_t         delta;
+	double         fractional_shift = -1.0/declick;
+	double         fractional_pos;
+	gain_t         polscale = invert_polarity ? -1.0f : 1.0f;
+
+	if (target < initial) {
+		/* fade out: remove more and more of delta from initial */
+		delta = -(initial - target);
+	} else {
+		/* fade in: add more and more of delta from initial */
+		delta = target - initial;
+	}
+
+	for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+		Sample* const buffer = i->data();
+
+		fractional_pos = 1.0;
+
+		for (nframes_t nx = 0; nx < declick; ++nx) {
+			buffer[nx] *= polscale * (initial + (delta * (0.5 + 0.5 * cos (M_PI * fractional_pos))));
+			fractional_pos += fractional_shift;
+		}
+		
+		/* now ensure the rest of the buffer has the target value applied, if necessary. */
+		
+		if (declick != nframes) {
+
+			if (invert_polarity) {
+				target = -target;
+			}
+
+			if (target == 0.0) {
+				memset (&buffer[declick], 0, sizeof (Sample) * (nframes - declick));
+			} else if (target != 1.0) {
+				apply_gain_to_buffer (&buffer[declick], nframes - declick, target);
+			}
+		}
+	}
+}
+
+void
+Amp::apply_simple_gain (BufferSet& bufs, nframes_t nframes, gain_t target)
+{
+}
+
+
+} // namespace ARDOUR
diff --git a/libs/ardour/ardour/amp.h b/libs/ardour/ardour/amp.h
new file mode 100644
index 0000000000..c3049c1e8b
--- /dev/null
+++ b/libs/ardour/ardour/amp.h
@@ -0,0 +1,42 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_amp_h__
+#define __ardour_amp_h__
+
+#include <ardour/types.h>
+
+namespace ARDOUR {
+
+class BufferSet;
+
+
+/** Applies a declick operation to all audio inputs, passing the same number of
+ * audio outputs, and passing through any other types unchanged.
+ */
+class Amp {
+public:
+	static void run (BufferSet& bufs, nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity);
+
+	static void apply_simple_gain(BufferSet& bufs, nframes_t nframes, gain_t target);
+};
+
+
+} // namespace ARDOUR
+
+#endif // __ardour_amp_h__
diff --git a/libs/ardour/ardour/ardour.h b/libs/ardour/ardour/ardour.h
index 09c6bd8856..e1be7ad998 100644
--- a/libs/ardour/ardour/ardour.h
+++ b/libs/ardour/ardour/ardour.h
@@ -46,6 +46,8 @@ namespace ARDOUR {
 
 	int init (bool with_vst, bool try_optimization);
 	int cleanup ();
+
+	int setup_midi(AudioEngine& engine);
 	
 	std::string get_ardour_revision ();
 	
diff --git a/libs/ardour/ardour/audio_port.h b/libs/ardour/ardour/audio_port.h
new file mode 100644
index 0000000000..0e85e0e01b
--- /dev/null
+++ b/libs/ardour/ardour/audio_port.h
@@ -0,0 +1,103 @@
+/*
+    Copyright (C) 2002 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: port.h 712 2006-07-28 01:08:57Z drobilla $
+*/
+
+#ifndef __ardour_audio_port_h__
+#define __ardour_audio_port_h__
+
+#include <sigc++/signal.h>
+#include <pbd/failed_constructor.h>
+#include <ardour/ardour.h>
+#include <jack/jack.h>
+#include <ardour/port.h>
+#include <ardour/buffer.h>
+
+namespace ARDOUR {
+
+class AudioEngine;
+
+class AudioPort : public Port {
+   public:
+	virtual ~AudioPort() { 
+		free (_port);
+	}
+
+	void cycle_start(nframes_t nframes) {
+		_buffer.set_data ((Sample*) jack_port_get_buffer (_port, nframes), nframes);
+	}
+
+	void cycle_end() {}
+
+	DataType type() const { return DataType(DataType::AUDIO); }
+
+	Buffer& get_buffer () {
+		return _buffer;
+	}
+	
+	AudioBuffer& get_audio_buffer() {
+		return _buffer;
+	}
+
+	void reset_overs () {
+		_short_overs = 0;
+		_long_overs = 0;
+		_overlen = 0;
+	}
+
+	void reset_peak_meter () {
+		_peak = 0;
+	}
+	
+	void reset_meters () {
+		reset_peak_meter ();
+		reset_overs ();
+	}
+
+	float                       peak_db() const { return _peak_db; }
+	jack_default_audio_sample_t peak()    const { return _peak; }
+
+	uint32_t short_overs () const { return _short_overs; }
+	uint32_t long_overs ()  const { return _long_overs; }
+	
+	static void set_short_over_length (nframes_t);
+	static void set_long_over_length (nframes_t);
+
+  protected:
+	friend class AudioEngine;
+
+	AudioPort (jack_port_t *port);
+	void reset ();
+	
+	/* engine isn't supposed to access below here */
+
+	AudioBuffer _buffer;
+
+	nframes_t               _overlen;
+	jack_default_audio_sample_t  _peak;
+	float                        _peak_db;
+	uint32_t                     _short_overs;
+	uint32_t                     _long_overs;
+	
+	static nframes_t        _long_over_length;
+	static nframes_t        _short_over_length;
+};
+ 
+} // namespace ARDOUR
+
+#endif /* __ardour_audio_port_h__ */
diff --git a/libs/ardour/ardour/audio_track.h b/libs/ardour/ardour/audio_track.h
index 0405c30301..3546545329 100644
--- a/libs/ardour/ardour/audio_track.h
+++ b/libs/ardour/ardour/audio_track.h
@@ -53,7 +53,7 @@ class AudioTrack : public Track
 	int use_diskstream (string name);
 	int use_diskstream (const PBD::ID& id);
 	
-	int export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t nframes, nframes_t end_frame);
+	int export_stuff (BufferSet& bufs, nframes_t nframes, nframes_t end_frame);
 
 	void freeze (InterThreadInfo&);
 	void unfreeze ();
@@ -65,15 +65,9 @@ class AudioTrack : public Track
 
   protected:
 	XMLNode& state (bool full);
-
-	void passthru_silence (nframes_t start_frame, nframes_t end_frame, 
-			       nframes_t nframes, nframes_t offset, int declick,
-			       bool meter);
-
-	uint32_t n_process_buffers ();
-
-	int _set_state (const XMLNode&, bool call_base);
 	
+	int _set_state (const XMLNode&, bool call_base);
+
   private:
 	int  set_diskstream (boost::shared_ptr<AudioDiskstream>, void *);
 	int  deprecated_use_diskstream_connections ();
diff --git a/libs/ardour/ardour/audio_unit.h b/libs/ardour/ardour/audio_unit.h
index a3d6074722..88591ab845 100644
--- a/libs/ardour/ardour/audio_unit.h
+++ b/libs/ardour/ardour/audio_unit.h
@@ -64,8 +64,11 @@ class AUPlugin : public ARDOUR::Plugin
 	void deactivate ();
 	void set_block_size (nframes_t nframes);
     
-	int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset);
+	int connect_and_run (BufferSet& bufs, uint32_t& in, uint32_t& out, nframes_t nframes, nframes_t offset);
+	
 	std::set<uint32_t> automatable() const;
+	void store_state (ARDOUR::PluginState&);
+	void restore_state (ARDOUR::PluginState&);
 	string describe_parameter (uint32_t);
 	string state_node_name () const { return "audiounit"; }
 	void print_parameter (uint32_t, char*, uint32_t len) const;
diff --git a/libs/ardour/ardour/audioengine.h b/libs/ardour/ardour/audioengine.h
index 0b423a7e28..a95bc0472b 100644
--- a/libs/ardour/ardour/audioengine.h
+++ b/libs/ardour/ardour/audioengine.h
@@ -46,6 +46,8 @@ class Port;
 class AudioEngine : public sigc::trackable
 {
    public:
+	typedef std::set<Port*> Ports;
+
 	AudioEngine (std::string client_name);
 	virtual ~AudioEngine ();
 	
@@ -113,11 +115,11 @@ class AudioEngine : public sigc::trackable
 
 	Port *register_input_port (DataType type, const std::string& portname);
 	Port *register_output_port (DataType type, const std::string& portname);
-	int   unregister_port (Port *);
+	int   unregister_port (Port &);
 	
 	int connect (const std::string& source, const std::string& destination);
 	int disconnect (const std::string& source, const std::string& destination);
-	int disconnect (Port *);
+	int disconnect (Port &);
 	
 	const char ** get_ports (const std::string& port_name_pattern, const std::string& type_name_pattern, uint32_t flags);
 
@@ -127,21 +129,19 @@ class AudioEngine : public sigc::trackable
 	void get_physical_outputs (std::vector<std::string>&);
 	void get_physical_inputs (std::vector<std::string>&);
 
-	std::string get_nth_physical_output (uint32_t n) {
-		return get_nth_physical (n, JackPortIsInput);
+	std::string get_nth_physical_output (DataType type, uint32_t n) {
+		return get_nth_physical (type, n, JackPortIsInput);
 	}
 
-	std::string get_nth_physical_input (uint32_t n) {
-		return get_nth_physical (n, JackPortIsOutput);
+	std::string get_nth_physical_input (DataType type, uint32_t n) {
+		return get_nth_physical (type, n, JackPortIsOutput);
 	}
 
 	nframes_t get_port_total_latency (const Port&);
 	void update_total_latencies ();
 
-	/* the caller may not delete the object pointed to by 
-	   the return value
+	/** Caller may not delete the object pointed to by the return value
 	*/
-
 	Port *get_port_by_name (const std::string& name, bool keep = true);
 
 	enum TransportState {
@@ -213,7 +213,6 @@ class AudioEngine : public sigc::trackable
 	bool                  reconnect_on_halt;
 	int                  _usecs_per_cycle;
 
-	typedef std::set<Port*> Ports;
 	SerializedRCUManager<Ports> ports;
 
 	int    process_callback (nframes_t nframes);
@@ -223,9 +222,9 @@ class AudioEngine : public sigc::trackable
 	typedef std::list<PortConnection> PortConnections;
 
 	PortConnections port_connections;
-	void   remove_connections_for (Port*);
+	void   remove_connections_for (Port&);
 
-	std::string get_nth_physical (uint32_t which, int flags);
+	std::string get_nth_physical (DataType type, uint32_t n, int flags);
 
 	static int  _xrun_callback (void *arg);
 	static int  _graph_order_callback (void *arg);
diff --git a/libs/ardour/ardour/audiofilesource.h b/libs/ardour/ardour/audiofilesource.h
index dce06c1ca0..149ceb7dc3 100644
--- a/libs/ardour/ardour/audiofilesource.h
+++ b/libs/ardour/ardour/audiofilesource.h
@@ -121,7 +121,7 @@ class AudioFileSource : public AudioSource {
 	   to cause issues.
 	*/
 
-	virtual void handle_header_position_change () {}
+	virtual void handle_header_position_change ();
 
   protected:
 	
diff --git a/libs/ardour/ardour/audioplaylist.h b/libs/ardour/ardour/audioplaylist.h
index 38084a1f7a..39f41d5d1c 100644
--- a/libs/ardour/ardour/audioplaylist.h
+++ b/libs/ardour/ardour/audioplaylist.h
@@ -44,7 +44,7 @@ class AudioPlaylist : public ARDOUR::Playlist
 	AudioPlaylist (boost::shared_ptr<const AudioPlaylist>, string name, bool hidden = false);
 	AudioPlaylist (boost::shared_ptr<const AudioPlaylist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
 
-       ~AudioPlaylist (); /* public should use unref() */
+	~AudioPlaylist ();
 
 	void clear (bool with_signals=true);
 
diff --git a/libs/ardour/ardour/audioregion.h b/libs/ardour/ardour/audioregion.h
index a450d90008..23841af095 100644
--- a/libs/ardour/ardour/audioregion.h
+++ b/libs/ardour/ardour/audioregion.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000-2001 Paul Davis 
+    Copyright (C) 2000-2006 Paul Davis 
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -54,24 +54,18 @@ class AudioRegion : public Region
 
 	~AudioRegion();
 
-	bool source_equivalent (boost::shared_ptr<const Region>) const;
-
 	bool speed_mismatch (float) const;
 
-	boost::shared_ptr<AudioSource> source (uint32_t n=0) const { if (n < sources.size()) return sources[n]; else return sources[0]; } 
+	boost::shared_ptr<AudioSource> audio_source (uint32_t n=0) const;
 
-	void set_scale_amplitude (gain_t);
+	void   set_scale_amplitude (gain_t);
 	gain_t scale_amplitude() const { return _scale_amplitude; }
 	
 	void normalize_to (float target_in_dB = 0.0f);
 
-	uint32_t n_channels() const { return sources.size(); }
-	vector<string> master_source_names();
-	
 	bool envelope_active () const { return _flags & Region::EnvelopeActive; }
 	bool fade_in_active ()  const { return _flags & Region::FadeIn; }
 	bool fade_out_active () const { return _flags & Region::FadeOut; }
-	bool captured() const { return !(_flags & (Region::Flag (Region::Import|Region::External))); }
 
 	Curve& fade_in()  { return _fade_in; }
 	Curve& fade_out() { return _fade_out; }
@@ -129,8 +123,6 @@ class AudioRegion : public Region
 
 	int exportme (ARDOUR::Session&, ARDOUR::AudioExportSpecification&);
 
-	boost::shared_ptr<Region> get_parent() const;
-
 	/* xfade/fade interactions */
 
 	void suspend_fade_in ();
@@ -138,8 +130,6 @@ class AudioRegion : public Region
 	void resume_fade_in ();
 	void resume_fade_out ();
 
-	void set_playlist (boost::weak_ptr<Playlist>);
-
   private:
 	friend class RegionFactory;
 
@@ -165,10 +155,6 @@ class AudioRegion : public Region
 				 nframes_t read_frames = 0,
 				 nframes_t skip_frames = 0) const;
 
-	bool verify_start (nframes_t position);
-	bool verify_length (nframes_t position);
-	bool verify_start_mutable (nframes_t& start);
-	bool verify_start_and_length (nframes_t start, nframes_t length);
 	void recompute_at_start ();
 	void recompute_at_end ();
 
@@ -178,13 +164,6 @@ class AudioRegion : public Region
 	void source_offset_changed ();
 	void listen_to_my_curves ();
 
-	void source_deleted ();
-	
-	SourceList        sources;
-	
-	/** Used when timefx are applied, so we can always use the original source. */
-	SourceList        master_sources; 
-
 	mutable Curve     _fade_in;
 	FadeShape         _fade_in_shape;
 	mutable Curve     _fade_out;
@@ -196,6 +175,13 @@ class AudioRegion : public Region
 
   protected:
 	int set_live_state (const XMLNode&, Change&, bool send);
+	
+	virtual bool verify_start (nframes_t);
+	virtual bool verify_start_and_length (nframes_t, nframes_t);
+	virtual bool verify_start_mutable (nframes_t&_start);
+	virtual bool verify_length (nframes_t);
+	/*virtual void recompute_at_start () = 0;
+	virtual void recompute_at_end () = 0;*/
 };
 
 } /* namespace ARDOUR */
diff --git a/libs/ardour/ardour/audiosource.h b/libs/ardour/ardour/audiosource.h
index b1062c43a9..812c30e8c2 100644
--- a/libs/ardour/ardour/audiosource.h
+++ b/libs/ardour/ardour/audiosource.h
@@ -52,20 +52,7 @@ const nframes_t frames_per_peak = 256;
 	AudioSource (Session&, ustring name);
 	AudioSource (Session&, const XMLNode&);
 	virtual ~AudioSource ();
-
-	/* one could argue that this should belong to Source, but other data types
-	   generally do not come with a model of "offset along an audio timeline"
-	   so its here in AudioSource for now.
-	*/
-
-	virtual nframes_t natural_position() const { return 0; }
 	
-	/* returns the number of items in this `audio_source' */
-
-	virtual nframes_t length() const {
-		return _length;
-	}
-
 	virtual nframes_t available_peaks (double zoom) const;
 
 	virtual nframes_t read (Sample *dst, nframes_t start, nframes_t cnt) const;
@@ -116,7 +103,6 @@ const nframes_t frames_per_peak = 256;
 
 	bool                _peaks_built;
 	mutable Glib::Mutex _lock;
-	nframes_t           _length;
 	ustring               peakpath;
 	ustring              _captured_for;
 
@@ -135,8 +121,6 @@ const nframes_t frames_per_peak = 256;
 	virtual ustring peak_path(ustring audio_path) = 0;
 	virtual ustring old_peak_path(ustring audio_path) = 0;
 	
-	void update_length (nframes_t pos, nframes_t cnt);
-
   private:
 	int peakfile;
 	nframes_t peak_leftover_cnt;
diff --git a/libs/ardour/ardour/buffer.h b/libs/ardour/ardour/buffer.h
index 8a88802ecb..b890afbb03 100644
--- a/libs/ardour/ardour/buffer.h
+++ b/libs/ardour/ardour/buffer.h
@@ -19,19 +19,16 @@
 #ifndef __ardour_buffer_h__
 #define __ardour_buffer_h__
 
-#define _XOPEN_SOURCE 600
-#include <cstdlib> // for posix_memalign
+#include <cstdlib>
 #include <cassert>
+#include <iostream>
 #include <ardour/types.h>
 #include <ardour/data_type.h>
+#include <ardour/runtime_functions.h>
 
 namespace ARDOUR {
 
 
-/* Yes, this is a bit of a mess right now.  I'll clean it up when everything
- * using it works out.. */
-
-
 /** A buffer of recordable/playable data.
  *
  * This is a datatype-agnostic base class for all buffers (there are no
@@ -44,12 +41,11 @@ namespace ARDOUR {
 class Buffer
 {
 public:
-	Buffer(DataType type, size_t capacity)
-	: _type(type), _capacity(capacity), _size(0) 
-	{}
-
 	virtual ~Buffer() {}
 
+	/** Factory function */
+	static Buffer* create(DataType type, size_t capacity);
+
 	/** Maximum capacity of buffer.
 	 * Note in some cases the entire buffer may not contain valid data, use size. */
 	size_t capacity() const { return _capacity; }
@@ -61,10 +57,30 @@ public:
 	 * Based on this you can static cast a Buffer* to the desired type. */
 	DataType type() const { return _type; }
 
+	bool silent() const { return _silent; }
+
+	/** Clear (eg zero, or empty) buffer starting at TIME @a offset */
+	virtual void silence(nframes_t len, nframes_t offset=0) = 0;
+	
+	/** Clear the entire buffer */
+	virtual void clear() { silence(_capacity, 0); }
+
+	virtual void read_from(const Buffer& src, nframes_t offset, nframes_t len) = 0;
+
 protected:
+	Buffer(DataType type, size_t capacity)
+	: _type(type), _capacity(capacity), _size(0), _silent(true)
+	{}
+
 	DataType _type;
 	size_t   _capacity;
 	size_t   _size;
+	bool     _silent;
+
+private:
+	// Prevent copies (undefined)
+	Buffer(const Buffer& copy);
+	void operator=(const Buffer& other);
 };
 
 
@@ -75,32 +91,140 @@ protected:
 class AudioBuffer : public Buffer
 {
 public:
-	AudioBuffer(size_t capacity)
-		: Buffer(DataType::AUDIO, capacity)
-		, _data(NULL)
+	AudioBuffer(size_t capacity);
+	
+	~AudioBuffer();
+
+	void silence(nframes_t len, nframes_t offset=0)
+	{
+		if (!_silent) {
+			assert(_capacity > 0);
+			assert(offset + len <= _capacity);
+			memset(_data + offset, 0, sizeof (Sample) * len);
+			if (offset == 0 && len == _capacity) {
+				_silent = true;
+			}
+		}
+	}
+	
+	/** Read @a len frames FROM THE START OF @a src into self at @a offset */
+	void read_from(const Buffer& src, nframes_t len, nframes_t offset)
+	{
+		assert(_capacity > 0);
+		assert(src.type() == _type == DataType::AUDIO);
+		assert(offset + len <= _capacity);
+		memcpy(_data + offset, ((AudioBuffer&)src).data(), sizeof(Sample) * len);
+		_silent = src.silent();
+	}
+	
+	/** Accumulate (add)@a len frames FROM THE START OF @a src into self at @a offset */
+	void accumulate_from(const AudioBuffer& src, nframes_t len, nframes_t offset)
+	{
+		assert(_capacity > 0);
+		assert(offset + len <= _capacity);
+
+		Sample*       const dst_raw = _data + offset;
+		const Sample* const src_raw = src.data();
+
+		for (nframes_t n = 0; n < len; ++n) {
+			dst_raw[n] += src_raw[n];
+		}
+
+		_silent = (src.silent() && _silent);
+	}
+	
+	/** Accumulate (add) @a len frames FROM THE START OF @a src into self at @a offset
+	 * scaling by @a gain_coeff */
+	void accumulate_with_gain_from(const AudioBuffer& src, nframes_t len, nframes_t offset, gain_t gain_coeff)
+	{
+		assert(_capacity > 0);
+		assert(offset + len <= _capacity);
+
+		Sample*       const dst_raw = _data + offset;
+		const Sample* const src_raw = src.data();
+
+		mix_buffers_with_gain (dst_raw, src_raw, len, gain_coeff);
+
+		_silent = ( (src.silent() && _silent) || (_silent && gain_coeff == 0) );
+	}
+	
+	void apply_gain(gain_t gain, nframes_t len, nframes_t offset=0) {
+		apply_gain_to_buffer (_data + offset, len, gain);
+	}
+
+	/** Set the data contained by this buffer manually (for setting directly to jack buffer).
+	 * 
+	 * Constructor MUST have been passed capacity=0 or this will die (to prevent mem leaks).
+	 */
+	void set_data(Sample* data, size_t size)
 	{
-		_size = capacity; // For audio buffers, size = capacity (always)
-#ifdef NO_POSIX_MEMALIGN
-		_data =  (Sample *) malloc(sizeof(Sample) * capacity);
-#else
-		posix_memalign((void**)_data, 16, sizeof(Sample) * capacity);
-#endif	
-		assert(_data);
-		memset(_data, 0, sizeof(Sample) * capacity);
+		assert(!_owns_data); // prevent leaks
+		_capacity = size;
+		_size = size;
+		_data = data;
+		_silent = false;
 	}
 
-	const Sample* data() const { return _data; }
-	Sample*       data()       { return _data; }
+	const Sample* data () const { return _data; }
+	Sample* data () { return _data; }
+
+	const Sample* data(nframes_t nframes, nframes_t offset) const
+		{ assert(offset + nframes <= _capacity); return _data + offset; }
+
+	Sample* data (nframes_t nframes, nframes_t offset)
+		{ assert(offset + nframes <= _capacity); return _data + offset; }
 
 private:
 	// These are undefined (prevent copies)
 	AudioBuffer(const AudioBuffer& copy);            
 	AudioBuffer& operator=(const AudioBuffer& copy);
 
+	bool    _owns_data;
 	Sample* _data; ///< Actual buffer contents
 };
 
 
+
+/** Buffer containing 8-bit unsigned char (MIDI) data. */
+class MidiBuffer : public Buffer
+{
+public:
+	MidiBuffer(size_t capacity);
+	
+	~MidiBuffer();
+
+	void silence(nframes_t dur, nframes_t offset=0);
+	
+	void read_from(const Buffer& src, nframes_t nframes, nframes_t offset);
+
+	bool push_back(const MidiEvent& event);
+	
+	const MidiEvent& operator[](size_t i) const { assert(i < _size); return _events[i]; }
+	MidiEvent& operator[](size_t i) { assert(i < _size); return _events[i]; }
+
+	static size_t max_event_size() { return MAX_EVENT_SIZE; }
+
+	//void set_size(size_t size) { _size = size; }
+
+	//const RawMidi* data() const { return _data; }
+	//RawMidi*       data()       { return _data; }
+
+private:
+	// These are undefined (prevent copies)
+	MidiBuffer(const MidiBuffer& copy);            
+	MidiBuffer& operator=(const MidiBuffer& copy);
+
+	// FIXME: Jack needs to tell us this
+	static const size_t MAX_EVENT_SIZE = 4; // bytes
+	
+	/* We use _size as "number of events", so the size of _data is
+	 * (_size * MAX_EVENT_SIZE)
+	 */
+
+	MidiEvent* _events;     ///< Event structs that point to offsets in _data
+	RawMidi*   _data;       ///< MIDI, straight up.  No time stamps.
+};
+
 } // namespace ARDOUR
 
 #endif // __ardour_buffer_h__
diff --git a/libs/ardour/ardour/buffer_set.h b/libs/ardour/ardour/buffer_set.h
new file mode 100644
index 0000000000..3520f95eb3
--- /dev/null
+++ b/libs/ardour/ardour/buffer_set.h
@@ -0,0 +1,159 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_buffer_set_h__
+#define __ardour_buffer_set_h__
+
+#include <cassert>
+#include <vector>
+#include <ardour/chan_count.h>
+#include <ardour/data_type.h>
+
+namespace ARDOUR {
+
+class Buffer;
+class AudioBuffer;
+class MidiBuffer;
+class PortSet;
+
+
+/** A set of buffers of various types.
+ *
+ * These are mainly accessed from Session and passed around as scratch buffers
+ * (eg as parameters to run() methods) to do in-place signal processing.
+ *
+ * There are two types of counts associated with a BufferSet - available,
+ * and the 'use count'.  Available is the actual number of allocated buffers
+ * (and so is the maximum acceptable value for the use counts).
+ *
+ * The use counts are how things determine the form of their input and inform
+ * others the form of their output (eg what they did to the BufferSet).
+ * Setting the use counts is realtime safe.
+ */
+class BufferSet
+{
+public:
+	BufferSet();
+	~BufferSet();
+
+	void clear();
+	
+	void attach_buffers(PortSet& ports);
+
+	void ensure_buffers(const ChanCount& count, size_t buffer_capacity);
+	void ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capacity);
+
+	const ChanCount& available() const { return _available; }
+	ChanCount&       available()       { return _available; }
+
+	const ChanCount& count() const { return _count; }
+	ChanCount&       count()       { return _count; }
+
+	void set_count(const ChanCount& count) { _count = count; }
+	
+	size_t buffer_capacity(DataType type) const;
+
+	Buffer& get(DataType type, size_t i)
+	{
+		assert(i <= _count.get(type));
+		return *_buffers[type.to_index()][i];
+	}
+
+	AudioBuffer& get_audio(size_t i)
+	{
+		return (AudioBuffer&)get(DataType::AUDIO, i);
+	}
+	
+	MidiBuffer& get_midi(size_t i)
+	{
+		return (MidiBuffer&)get(DataType::MIDI, i);
+	}
+
+	void read_from(BufferSet& in, jack_nframes_t nframes, jack_nframes_t offset=0);
+
+	// ITERATORS
+	
+	// FIXME: this is a filthy copy-and-paste mess
+	// FIXME: litter these with assertions
+	
+	class audio_iterator {
+	public:
+
+		AudioBuffer& operator*()  { return _set.get_audio(_index); }
+		AudioBuffer* operator->() { return &_set.get_audio(_index); }
+		audio_iterator& operator++() { ++_index; return *this; } // yes, prefix only
+		bool operator==(const audio_iterator& other) { return (_index == other._index); }
+		bool operator!=(const audio_iterator& other) { return (_index != other._index); }
+
+	private:
+		friend class BufferSet;
+
+		audio_iterator(BufferSet& list, size_t index) : _set(list), _index(index) {}
+
+		BufferSet& _set;
+		size_t    _index;
+	};
+
+	audio_iterator audio_begin() { return audio_iterator(*this, 0); }
+	audio_iterator audio_end()   { return audio_iterator(*this, _count.get(DataType::AUDIO)); }
+
+	class iterator {
+	public:
+
+		Buffer& operator*()  { return _set.get(_type, _index); }
+		Buffer* operator->() { return &_set.get(_type, _index); }
+		iterator& operator++() { ++_index; return *this; } // yes, prefix only
+		bool operator==(const iterator& other) { return (_index == other._index); }
+		bool operator!=(const iterator& other) { return (_index != other._index); }
+		iterator operator=(const iterator& other) { _set = other._set; _type = other._type; _index = other._index; return *this; }
+
+	private:
+		friend class BufferSet;
+
+		iterator(BufferSet& list, DataType type, size_t index)
+			: _set(list), _type(type), _index(index) {}
+
+		BufferSet& _set;
+		DataType   _type;
+		size_t     _index;
+	};
+
+	iterator begin(DataType type) { return iterator(*this, type, 0); }
+	iterator end(DataType type)   { return iterator(*this, type, _count.get(type)); }
+
+	
+private:
+	typedef std::vector<Buffer*> BufferVec;
+
+	/// Vector of vectors, indexed by DataType::to_index()
+	std::vector<BufferVec> _buffers;
+
+	/// Use counts (there may be more actual buffers than this)
+	ChanCount _count;
+
+	/// Available counts (number of buffers actually allocated)
+	ChanCount _available;
+
+	/// Whether we (don't) 'own' the contained buffers (are a mirror of a PortSet)
+	bool _is_mirror;
+};
+
+
+} // namespace ARDOUR
+
+#endif // __ardour_buffer_set_h__
diff --git a/libs/ardour/ardour/chan_count.h b/libs/ardour/ardour/chan_count.h
new file mode 100644
index 0000000000..26e41a9bcd
--- /dev/null
+++ b/libs/ardour/ardour/chan_count.h
@@ -0,0 +1,115 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: insert.cc 712 2006-07-28 01:08:57Z drobilla $
+*/
+
+#ifndef __ardour_chan_count_h__
+#define __ardour_chan_count_h__
+
+#include <ardour/data_type.h>
+
+namespace ARDOUR {
+
+
+class ChanCount {
+public:
+	ChanCount() { reset(); }
+	
+	// Convenience constructor for making single-typed streams (stereo, mono, etc)
+	ChanCount(DataType type, size_t channels)
+	{
+		reset();
+		set(type, channels);
+	}
+
+	void reset()
+	{
+		for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+			_counts[(*t).to_index()] = 0;
+		}
+	}
+
+	void   set(DataType type, size_t count) { _counts[type.to_index()] = count; }
+	size_t get(DataType type) const { return _counts[type.to_index()]; }
+	
+	size_t get_total() const
+	{
+		size_t ret = 0;
+		for (size_t i=0; i < DataType::num_types; ++i)
+			ret += _counts[i];
+
+		return ret;
+	}
+
+	bool operator==(const ChanCount& other) const
+	{
+		for (size_t i=0; i < DataType::num_types; ++i)
+			if (_counts[i] != other._counts[i])
+				return false;
+
+		return true;
+	}
+	
+	bool operator!=(const ChanCount& other) const
+	{
+		return ! (*this == other);
+	}
+
+	bool operator<(const ChanCount& other) const
+	{
+		for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+			if (_counts[(*t).to_index()] > other._counts[(*t).to_index()]) {
+				return false;
+			}
+		}
+		return (*this != other);
+	}
+
+	bool operator<=(const ChanCount& other) const
+	{
+		return ( (*this < other) || (*this == other) );
+	}
+	
+	bool operator>(const ChanCount& other) const
+	{
+		for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+			if (_counts[(*t).to_index()] < other._counts[(*t).to_index()]) {
+				return false;
+			}
+		}
+		return (*this != other);
+	}
+
+	bool operator>=(const ChanCount& other) const
+	{
+		return ( (*this > other) || (*this == other) );
+	}
+
+	static const ChanCount INFINITE;
+	static const ChanCount ZERO;
+
+private:
+	
+	size_t _counts[DataType::num_types];
+};
+
+
+} // namespace ARDOUR
+
+#endif // __ardour_chan_count_h__
+
diff --git a/libs/ardour/ardour/data_type.h b/libs/ardour/ardour/data_type.h
index d49ed108cd..3818a8d74f 100644
--- a/libs/ardour/ardour/data_type.h
+++ b/libs/ardour/ardour/data_type.h
@@ -19,54 +19,103 @@
 #ifndef __ardour_data_type_h__
 #define __ardour_data_type_h__
 
+#include <string>
+#include <ardour/data_type.h>
 #include <jack/jack.h>
 
 namespace ARDOUR {
 
+
+/** A type of Data Ardour is capable of processing.
+ *
+ * The majority of this class is dedicated to conversion to and from various
+ * other type representations, simple comparison between then, etc.  This code
+ * is deliberately 'ugly' so other code doesn't have to be.
+ */
 class DataType
 {
 public:
+	/// WARNING: make REALLY sure you don't mess up indexes if you change this
 	enum Symbol {
 		NIL = 0,
 		AUDIO,
 		MIDI
 	};
+	
+	/** Number of types (not including NIL).
+	 * WARNING: make sure this matches Symbol!
+	 */
+	static const size_t num_types = 2;
 
 	DataType(const Symbol& symbol)
 	: _symbol(symbol)
 	{}
 
-	/** Construct from a string (Used for loading from XML) */
-	DataType(const string& str) {
+	/** Construct from a string (Used for loading from XML and Ports)
+	 * The string can be as in an XML file (eg "audio" or "midi"), or a
+	 * Jack type string (from jack_port_type) */
+	DataType(const std::string& str) {
 		if (str == "audio")
 			_symbol = AUDIO;
-		//else if (str == "midi")
-		//	_symbol = MIDI;
+		else if (str == JACK_DEFAULT_AUDIO_TYPE)
+			_symbol = AUDIO;
+		else if (str == "midi")
+			_symbol = MIDI;
+		else if (str == JACK_DEFAULT_MIDI_TYPE)
+			_symbol = MIDI;
 		else
 			_symbol = NIL;
 	}
 
-	bool operator==(const Symbol symbol) { return _symbol == symbol; }
-	bool operator!=(const Symbol symbol) { return _symbol != symbol; }
-
 	/** Get the Jack type this DataType corresponds to */
-	const char* to_jack_type() {
+	const char* to_jack_type() const {
 		switch (_symbol) {
 			case AUDIO: return JACK_DEFAULT_AUDIO_TYPE;
-			//case MIDI:  return JACK_DEFAULT_MIDI_TYPE;
+			case MIDI:  return JACK_DEFAULT_MIDI_TYPE;
 			default:    return "";
 		}
 	}
 	
 	/** Inverse of the from-string constructor */
-	const char* to_string() {
+	const char* to_string() const {
 		switch (_symbol) {
 			case AUDIO: return "audio";
-			//case MIDI:  return "midi";
+			case MIDI:  return "midi";
 			default:    return "unknown"; // reeeally shouldn't ever happen
 		}
 	}
 
+	//Symbol        to_symbol() const { return _symbol; }
+	inline size_t to_index() const { return (size_t)_symbol - 1; }
+
+	/** DataType iterator, for writing generic loops that iterate over all
+	 * available types.
+	 */
+	class iterator {
+	public:
+
+		iterator(size_t index) : _index(index) {}
+
+		DataType  operator*()  { return DataType((Symbol)_index); }
+		iterator& operator++() { ++_index; return *this; } // yes, prefix only
+		bool operator==(const iterator& other) { return (_index == other._index); }
+		bool operator!=(const iterator& other) { return (_index != other._index); }
+
+	private:
+		friend class DataType;
+
+		size_t _index;
+	};
+
+	static iterator begin() { return iterator(1); }
+	static iterator end()   { return iterator(num_types+1); }
+	
+	bool operator==(const Symbol symbol) { return (_symbol == symbol); }
+	bool operator!=(const Symbol symbol) { return (_symbol != symbol); }
+	
+	bool operator==(const DataType other) { return (_symbol == other._symbol); }
+	bool operator!=(const DataType other) { return (_symbol != other._symbol); }
+
 private:
 	Symbol _symbol;
 };
diff --git a/libs/ardour/ardour/diskstream.h b/libs/ardour/ardour/diskstream.h
index 79fec98d6e..4809e17868 100644
--- a/libs/ardour/ardour/diskstream.h
+++ b/libs/ardour/ardour/diskstream.h
@@ -114,7 +114,7 @@ class Diskstream : public PBD::StatefulDestructible
 	nframes_t get_capture_start_frame (uint32_t n=0);
 	nframes_t get_captured_frames (uint32_t n=0);
 	
-	uint32_t n_channels() { return _n_channels; }
+	ChanCount n_channels() { return _n_channels; }
 
 	static nframes_t disk_io_frames() { return disk_io_chunk_frames; }
 	static void set_disk_io_chunk_frames (uint32_t n) { disk_io_chunk_frames = n; }
@@ -123,7 +123,6 @@ class Diskstream : public PBD::StatefulDestructible
 	virtual XMLNode& get_state(void) = 0;
 	virtual int      set_state(const XMLNode& node) = 0;
 	
-	// FIXME: makes sense for all diskstream types?
 	virtual void monitor_input (bool) {}
 
 	nframes_t capture_offset() const { return _capture_offset; }
@@ -230,8 +229,8 @@ class Diskstream : public PBD::StatefulDestructible
 	virtual void get_input_sources () = 0;
 	virtual void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record) = 0;
 	virtual void set_align_style_from_io() {}
-	virtual void setup_destructive_playlist () = 0;
-	virtual void use_destructive_playlist () = 0;
+	virtual void setup_destructive_playlist () {}
+	virtual void use_destructive_playlist () {}
 
 	static nframes_t disk_io_chunk_frames;
 	std::vector<CaptureInfo*>  capture_info;
@@ -242,7 +241,7 @@ class Diskstream : public PBD::StatefulDestructible
 	string            _name;
 	ARDOUR::Session&  _session;
 	ARDOUR::IO*       _io;
-	uint32_t          _n_channels;
+	ChanCount         _n_channels;
 
 	boost::shared_ptr<Playlist> _playlist;
 
diff --git a/libs/ardour/ardour/insert.h b/libs/ardour/ardour/insert.h
index 9d063ca54b..e58cb71754 100644
--- a/libs/ardour/ardour/insert.h
+++ b/libs/ardour/ardour/insert.h
@@ -27,6 +27,7 @@
 #include <sigc++/signal.h>
 #include <ardour/ardour.h>
 #include <ardour/redirect.h>
+#include <ardour/plugin_state.h>
 #include <ardour/types.h>
 
 class XMLNode;
@@ -49,7 +50,8 @@ class Insert : public Redirect
 	
 	virtual ~Insert() { }
 
-	virtual void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset) = 0;
+	virtual void run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset) = 0;
+	
 	virtual void activate () {}
 	virtual void deactivate () {}
 
@@ -71,12 +73,13 @@ class PortInsert : public Insert
 	int set_state(const XMLNode&);
 
 	void init ();
-	void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+	
+	void run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset);
 
 	nframes_t latency();
 	
-	uint32_t output_streams() const;
-	uint32_t input_streams() const;
+	ChanCount output_streams() const;
+	ChanCount input_streams() const;
 
 	int32_t can_support_input_configuration (int32_t) const;
 	int32_t configure_io (int32_t magic, int32_t in, int32_t out);
@@ -102,17 +105,18 @@ class PluginInsert : public Insert
 	XMLNode& get_state(void);
 	int set_state(const XMLNode&);
 
-	void run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+	void run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset);
 	void silence (nframes_t nframes, nframes_t offset);
+	
 	void activate ();
 	void deactivate ();
 
 	void set_block_size (nframes_t nframes);
 
-	uint32_t output_streams() const;
-	uint32_t input_streams() const;
-	uint32_t natural_output_streams() const;
-	uint32_t natural_input_streams() const;
+	ChanCount output_streams() const;
+	ChanCount input_streams() const;
+	ChanCount natural_output_streams() const;
+	ChanCount natural_input_streams() const;
 
 	int      set_count (uint32_t num);
 	uint32_t get_count () const { return _plugins.size(); }
@@ -153,8 +157,9 @@ class PluginInsert : public Insert
 	void parameter_changed (uint32_t, float);
 	
 	vector<boost::shared_ptr<Plugin> > _plugins;
-	void automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
-	void connect_and_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now = 0);
+	
+	void automation_run (BufferSet& bufs, nframes_t nframes, nframes_t offset);
+	void connect_and_run (BufferSet& bufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now = 0);
 
 	void init ();
 	void set_automatable ();
diff --git a/libs/ardour/ardour/io.h b/libs/ardour/ardour/io.h
index ab918345b1..5c746d7376 100644
--- a/libs/ardour/ardour/io.h
+++ b/libs/ardour/ardour/io.h
@@ -38,6 +38,8 @@
 #include <ardour/curve.h>
 #include <ardour/types.h>
 #include <ardour/data_type.h>
+#include <ardour/port_set.h>
+#include <ardour/chan_count.h>
 
 using std::string;
 using std::vector;
@@ -48,9 +50,13 @@ namespace ARDOUR {
 
 class Session;
 class AudioEngine;
-class Port;
 class Connection;
 class Panner;
+class PeakMeter;
+class Port;
+class AudioPort;
+class MidiPort;
+class BufferSet;
 
 /** A collection of input and output ports with connections.
  *
@@ -67,50 +73,48 @@ class IO : public PBD::StatefulDestructible
 	    int input_min = -1, int input_max = -1, 
 	    int output_min = -1, int output_max = -1,
 	    DataType default_type = DataType::AUDIO);
-
+	
 	IO (Session&, const XMLNode&, DataType default_type = DataType::AUDIO);
-
+	
 	virtual ~IO();
 
-	int input_minimum() const { return _input_minimum; }
-	int input_maximum() const { return _input_maximum; }
-	int output_minimum() const { return _output_minimum; }
-	int output_maximum() const { return _output_maximum; }
-
-	void set_input_minimum (int n);
-	void set_input_maximum (int n);
-	void set_output_minimum (int n);
-	void set_output_maximum (int n);
-
-	DataType default_type() const { return _default_type; }
+	ChanCount input_minimum() const { return _input_minimum; }
+	ChanCount input_maximum() const { return _input_maximum; }
+	ChanCount output_minimum() const { return _output_minimum; }
+	ChanCount output_maximum() const { return _output_maximum; }
+	
+	void set_input_minimum (ChanCount n);
+	void set_input_maximum (ChanCount n);
+	void set_output_minimum (ChanCount n);
+	void set_output_maximum (ChanCount n);
+	
+	DataType default_type() const         { return _default_type; }
+	void     set_default_type(DataType t) { _default_type = t; }
 
 	const string& name() const { return _name; }
 	virtual int set_name (string str, void *src);
 	
 	virtual void silence  (nframes_t, nframes_t offset);
 
-	// These should be moved in to a separate object that manipulates an IO
-	
-	void pan (vector<Sample*>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, gain_t gain_coeff);
-	void pan_automated (vector<Sample*>& bufs, uint32_t nbufs, nframes_t start_frame, nframes_t end_frame, 
-			    nframes_t nframes, nframes_t offset);
-	void collect_input  (vector<Sample*>&, uint32_t nbufs, nframes_t nframes, nframes_t offset);
-	void deliver_output (vector<Sample*>&, uint32_t nbufs, nframes_t nframes, nframes_t offset);
-	void deliver_output_no_pan (vector<Sample*>&, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+	void collect_input  (BufferSet& bufs, nframes_t nframes, nframes_t offset);
+	void deliver_output (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame,
+	                                      nframes_t nframes, nframes_t offset);
 	void just_meter_input (nframes_t start_frame, nframes_t end_frame, 
 			       nframes_t nframes, nframes_t offset);
 
-	virtual uint32_t n_process_buffers () { return 0; }
-
 	virtual void   set_gain (gain_t g, void *src);
 	void           inc_gain (gain_t delta, void *src);
 	gain_t         gain () const { return _desired_gain; }
 	virtual gain_t effective_gain () const;
+	
+	void set_phase_invert (bool yn, void *src);
+	bool phase_invert() const { return _phase_invert; }
 
-	Panner& panner() { return *_panner; }
+	Panner& panner()        { return *_panner; }
+	PeakMeter& peak_meter() { return *_meter; }
 	const Panner& panner() const { return *_panner; }
 	
-	int ensure_io (uint32_t, uint32_t, bool clear, void *src);
+	int ensure_io (ChanCount in, ChanCount out, bool clear, void *src);
 
 	int use_input_connection (Connection&, void *src);
 	int use_output_connection (Connection&, void *src);
@@ -139,24 +143,34 @@ class IO : public PBD::StatefulDestructible
 	nframes_t input_latency() const;
 	void           set_port_latency (nframes_t);
 
+	const PortSet& inputs()  const { return _inputs; }
+	const PortSet& outputs() const { return _outputs; }
+
 	Port *output (uint32_t n) const {
-		if (n < _noutputs) {
-			return _outputs[n];
+		if (n < _outputs.num_ports()) {
+			return _outputs.port(n);
 		} else {
 			return 0;
 		}
 	}
 
 	Port *input (uint32_t n) const {
-		if (n < _ninputs) {
-			return _inputs[n];
+		if (n < _inputs.num_ports()) {
+			return _inputs.port(n);
 		} else {
 			return 0;
 		}
 	}
 
-	uint32_t n_inputs () const { return _ninputs; }
-	uint32_t n_outputs () const { return _noutputs; }
+	AudioPort* audio_input(uint32_t n) const;
+	AudioPort* audio_output(uint32_t n) const;
+	MidiPort*  midi_input(uint32_t n) const;
+	MidiPort*  midi_output(uint32_t n) const;
+
+	const ChanCount& n_inputs ()  const { return _inputs.count(); }
+	const ChanCount& n_outputs () const { return _outputs.count(); }
+
+	void attach_buffers(ChanCount ignored);
 
 	sigc::signal<void,IOChange,void*> input_changed;
 	sigc::signal<void,IOChange,void*> output_changed;
@@ -169,46 +183,26 @@ class IO : public PBD::StatefulDestructible
 	int set_state (const XMLNode&);
 
 	static int  disable_connecting (void);
+
 	static int  enable_connecting (void);
+
 	static int  disable_ports (void);
+
 	static int  enable_ports (void);
+
 	static int  disable_panners (void);
+
 	static int  reset_panners (void);
 	
-	static sigc::signal<int> PortsLegal;
-	static sigc::signal<int> PannersLegal;
-	static sigc::signal<int> ConnectingLegal;
-	static sigc::signal<void,uint32_t> MoreOutputs;
-	static sigc::signal<int> PortsCreated;
+	static sigc::signal<int>            PortsLegal;
+	static sigc::signal<int>            PannersLegal;
+	static sigc::signal<int>            ConnectingLegal;
+	static sigc::signal<void,ChanCount> MoreChannels;
+	static sigc::signal<int>            PortsCreated;
 
 	PBD::Controllable& gain_control() {
 		return _gain_control;
 	}
-
-	/* Peak metering */
-
-	float peak_input_power (uint32_t n) { 
-		if (_ninputs == 0) {
-			return minus_infinity();
-		} else if (n < std::max (_ninputs, _noutputs)) {
-			return _visible_peak_power[n];
-		} else {
-			return minus_infinity();
-		}
-	}
-
-	float max_peak_power (uint32_t n) {
-		if (_ninputs == 0) {
-			return minus_infinity();
-		} else if (n < std::max (_ninputs, _noutputs)) {
-			return _max_peak_power[n];
-		} else {
-			return minus_infinity();
-		}
-	}
-
-	void reset_max_peak_meters ();
-
 	
     static void update_meters();
 
@@ -222,11 +216,11 @@ class IO : public PBD::StatefulDestructible
 
 	/* automation */
 
-	static void set_automation_interval (jack_nframes_t frames) {
+	static void set_automation_interval (nframes_t frames) {
 		_automation_interval = frames;
 	}
 
-	static jack_nframes_t automation_interval() { 
+	static nframes_t automation_interval() { 
 		return _automation_interval;
 	}
 
@@ -277,33 +271,28 @@ class IO : public PBD::StatefulDestructible
   protected:
 	Session&            _session;
 	Panner*             _panner;
+	BufferSet*          _output_buffers; //< Set directly to output port buffers
 	gain_t              _gain;
 	gain_t              _effective_gain;
 	gain_t              _desired_gain;
 	Glib::Mutex         declick_lock;
-	vector<Port*>       _outputs;
-	vector<Port*>       _inputs;
-	vector<float>       _peak_power;
-	vector<float>       _visible_peak_power;
-	vector<float>       _max_peak_power;
+	PortSet             _outputs;
+	PortSet             _inputs;
+	PeakMeter*          _meter;
 	string              _name;
 	Connection*         _input_connection;
 	Connection*         _output_connection;
 	bool                 no_panner_reset;
+	bool                _phase_invert;
 	XMLNode*             deferred_state;
 	DataType            _default_type;
-	bool                _ignore_gain_on_deliver;
 	
-
 	virtual void set_deferred_state() {}
 
-	void reset_peak_meters();
 	void reset_panner ();
 
-	virtual uint32_t pans_required() const { return _ninputs; }
-
-	static void apply_declick (vector<Sample*>&, uint32_t nbufs, nframes_t nframes, 
-				   gain_t initial, gain_t target, bool invert_polarity);
+	virtual uint32_t pans_required() const
+		{ return _inputs.count().get(DataType::AUDIO); }
 
 	struct GainControllable : public PBD::Controllable {
 	    GainControllable (std::string name, IO& i) : Controllable (name), io (i) {}
@@ -339,10 +328,9 @@ class IO : public PBD::StatefulDestructible
 	static bool connecting_legal;
 	static bool ports_legal;
 
-  private:
+	BufferSet& output_buffers() { return *_output_buffers; }
 
-	uint32_t _ninputs;
-	uint32_t _noutputs;
+  private:
 
 	/* are these the best variable names ever, or what? */
 
@@ -359,10 +347,10 @@ class IO : public PBD::StatefulDestructible
 	sigc::connection port_legal_c;
 	sigc::connection panner_legal_c;
 
-	int _input_minimum;
-	int _input_maximum;
-	int _output_minimum;
-	int _output_maximum;
+	ChanCount _input_minimum;
+	ChanCount _input_maximum;
+	ChanCount _output_minimum;
+	ChanCount _output_maximum;
 
 
 	static int parse_io_string (const string&, vector<string>& chns);
@@ -372,8 +360,8 @@ class IO : public PBD::StatefulDestructible
 	int set_sources (vector<string>&, void *src, bool add);
 	int set_destinations (vector<string>&, void *src, bool add);
 
-	int ensure_inputs (uint32_t, bool clear, bool lockit, void *src);
-	int ensure_outputs (uint32_t, bool clear, bool lockit, void *src);
+	int ensure_inputs (ChanCount, bool clear, bool lockit, void *src);
+	int ensure_outputs (ChanCount, bool clear, bool lockit, void *src);
 
 	void drop_input_connection ();
 	void drop_output_connection ();
@@ -389,8 +377,8 @@ class IO : public PBD::StatefulDestructible
 	void setup_peak_meters ();
 	void meter ();
 
-	bool ensure_inputs_locked (uint32_t, bool clear, void *src);
-	bool ensure_outputs_locked (uint32_t, bool clear, void *src);
+	bool ensure_inputs_locked (ChanCount, bool clear, void *src);
+	bool ensure_outputs_locked (ChanCount, bool clear, void *src);
 
 	int32_t find_input_port_hole ();
 	int32_t find_output_port_hole ();
diff --git a/libs/ardour/ardour/ladspa_plugin.h b/libs/ardour/ardour/ladspa_plugin.h
index 63f8f600d3..f1f1bb8811 100644
--- a/libs/ardour/ardour/ladspa_plugin.h
+++ b/libs/ardour/ardour/ladspa_plugin.h
@@ -32,6 +32,7 @@
 
 #include <jack/types.h>
 #include <ardour/ladspa.h>
+#include <ardour/plugin_state.h>
 #include <ardour/plugin.h>
 #include <ardour/ladspa_plugin.h>
 
@@ -81,7 +82,9 @@ class LadspaPlugin : public ARDOUR::Plugin
 	}
 	void set_block_size (nframes_t nframes) {}
 	
-	int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset);
+	int connect_and_run (BufferSet& bufs, uint32_t& in, uint32_t& out, nframes_t nframes, nframes_t offset);
+	void store_state (ARDOUR::PluginState&);
+	void restore_state (ARDOUR::PluginState&);
 	string describe_parameter (uint32_t);
 	string state_node_name() const { return "ladspa"; }
 	void print_parameter (uint32_t, char*, uint32_t len) const;
diff --git a/libs/ardour/ardour/meter.h b/libs/ardour/ardour/meter.h
new file mode 100644
index 0000000000..ed38fc4f0a
--- /dev/null
+++ b/libs/ardour/ardour/meter.h
@@ -0,0 +1,76 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_meter_h__
+#define __ardour_meter_h__
+
+#include <vector>
+#include <ardour/types.h>
+#include <pbd/fastlog.h>
+
+namespace ARDOUR {
+
+class BufferSet;
+class ChanCount;
+class Session;
+
+
+/** Meters peaks on the input and stores them for access.
+ */
+class PeakMeter {
+public:
+	PeakMeter(Session& s) : _session(s) {}
+
+	void setup (const ChanCount& in);
+	void reset ();
+	void reset_max ();
+
+	/** Compute peaks */
+	void run (BufferSet& bufs, nframes_t nframes, nframes_t offset=0);
+	
+	float peak_power (uint32_t n) { 
+		if (n < _visible_peak_power.size()) {
+			return _visible_peak_power[n];
+		} else {
+			return minus_infinity();
+		}
+	}
+	
+	float max_peak_power (uint32_t n) {
+		if (n < _max_peak_power.size()) {
+			return _max_peak_power[n];
+		} else {
+			return minus_infinity();
+		}
+	}
+
+private:
+	
+	friend class IO;
+	void meter();
+
+	Session&           _session;
+	std::vector<float> _peak_power;
+	std::vector<float> _visible_peak_power;
+	std::vector<float> _max_peak_power;
+};
+
+
+} // namespace ARDOUR
+
+#endif // __ardour_meter_h__
diff --git a/libs/ardour/ardour/midi_diskstream.h b/libs/ardour/ardour/midi_diskstream.h
new file mode 100644
index 0000000000..bc126ce364
--- /dev/null
+++ b/libs/ardour/ardour/midi_diskstream.h
@@ -0,0 +1,165 @@
+/*
+    Copyright (C) 2000 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: diskstream.h 579 2006-06-12 19:56:37Z essej $
+*/
+
+#ifndef __ardour_midi_diskstream_h__
+#define __ardour_midi_diskstream_h__
+
+#include <sigc++/signal.h>
+
+#include <cmath>
+#include <cassert>
+#include <string>
+#include <queue>
+#include <map>
+#include <vector>
+
+#include <time.h>
+
+#include <pbd/fastlog.h>
+#include <pbd/ringbufferNPT.h>
+ 
+
+#include <ardour/ardour.h>
+#include <ardour/configuration.h>
+#include <ardour/session.h>
+#include <ardour/route_group.h>
+#include <ardour/route.h>
+#include <ardour/port.h>
+#include <ardour/utils.h>
+#include <ardour/diskstream.h>
+#include <ardour/midi_playlist.h>
+#include <ardour/midi_ring_buffer.h>
+
+struct tm;
+
+namespace ARDOUR {
+
+class MidiEngine;
+class Send;
+class Session;
+class MidiPlaylist;
+class SMFSource;
+class IO;
+
+class MidiDiskstream : public Diskstream
+{	
+  public:
+	MidiDiskstream (Session &, const string& name, Diskstream::Flag f = Recordable);
+	MidiDiskstream (Session &, const XMLNode&);
+	~MidiDiskstream();
+
+	float playback_buffer_load() const;
+	float capture_buffer_load() const;
+	
+	void get_playback(MidiBuffer& dst, nframes_t start, nframes_t end);
+
+	void set_record_enabled (bool yn);
+
+	boost::shared_ptr<MidiPlaylist> midi_playlist () { return boost::dynamic_pointer_cast<MidiPlaylist>(_playlist); }
+
+	int use_playlist (boost::shared_ptr<Playlist>);
+	int use_new_playlist ();
+	int use_copy_playlist ();
+
+	/* stateful */
+
+	XMLNode& get_state(void);
+	int set_state(const XMLNode& node);
+
+	void monitor_input (bool);
+
+	boost::shared_ptr<SMFSource> write_source () { return _write_source; }
+	
+	int set_destructive (bool yn); // doom!
+
+  protected:
+	friend class Session;
+
+	/* the Session is the only point of access for these
+	   because they require that the Session is "inactive"
+	   while they are called.
+	*/
+
+	void set_pending_overwrite(bool);
+	int  overwrite_existing_buffers ();
+	void set_block_size (nframes_t);
+	int  internal_playback_seek (nframes_t distance);
+	int  can_internal_playback_seek (nframes_t distance);
+	int  rename_write_sources ();
+	void reset_write_sources (bool, bool force = false);
+	void non_realtime_input_change ();
+
+  protected:
+	int seek (nframes_t which_sample, bool complete_refill = false);
+
+  protected:
+	friend class MidiTrack;
+
+	int  process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input);
+	bool commit  (nframes_t nframes);
+
+  private:
+
+	/* The two central butler operations */
+	int do_flush (Session::RunContext context, bool force = false);
+	int do_refill ();
+	
+	int do_refill_with_alloc();
+
+	int read (nframes_t& start, nframes_t cnt, bool reversed);
+
+	void finish_capture (bool rec_monitors_input);
+	void transport_stopped (struct tm&, time_t, bool abort);
+
+	void init (Diskstream::Flag);
+
+	int use_new_write_source (uint32_t n=0);
+
+	int find_and_use_playlist (const string&);
+
+	void allocate_temporary_buffers ();
+
+	int use_pending_capture_data (XMLNode& node);
+
+	void get_input_sources ();
+	void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record);
+	void set_align_style_from_io();
+	
+	void engage_record_enable ();
+	void disengage_record_enable ();
+	
+	// FIXME: This is basically a single ChannelInfo.. abstractify that concept?
+	MidiRingBuffer*                    _playback_buf;
+	MidiRingBuffer*                    _capture_buf;
+	//RawMidi*                          _current_playback_buffer;
+	//RawMidi*                          _current_capture_buffer;
+	//RawMidi*                          _playback_wrap_buffer;
+	//RawMidi*                          _capture_wrap_buffer;
+	MidiPort*                         _source_port;
+	boost::shared_ptr<SMFSource>      _write_source;
+	RingBufferNPT<CaptureTransition>* _capture_transition_buf;
+	//RingBufferNPT<RawMidi>::rw_vector _playback_vector;
+	//RingBufferNPT<RawMidi>::rw_vector _capture_vector;
+	nframes_t _last_flush_frame;
+};
+
+}; /* namespace ARDOUR */
+
+#endif /* __ardour_midi_diskstream_h__ */
diff --git a/libs/ardour/ardour/midi_events.h b/libs/ardour/ardour/midi_events.h
new file mode 100644
index 0000000000..f7e2442109
--- /dev/null
+++ b/libs/ardour/ardour/midi_events.h
@@ -0,0 +1,136 @@
+/* Definitions to ease working with raw MIDI.
+ *
+ * Adapted from ALSA's asounddef.h
+ *
+ * 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.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef MIDI_H
+#define MIDI_H
+
+
+/**
+ * \defgroup midi MIDI Definitions
+ * MIDI command and controller number definitions.
+ * \{
+ */
+
+// Commands:
+
+#define MIDI_CMD_NOTE_OFF               0x80 /**< note off */
+#define MIDI_CMD_NOTE_ON                0x90 /**< note on */
+#define MIDI_CMD_NOTE_PRESSURE          0xA0 /**< key pressure */
+#define MIDI_CMD_CONTROL                0xB0 /**< control change */
+#define MIDI_CMD_PGM_CHANGE             0xC0 /**< program change */
+#define MIDI_CMD_CHANNEL_PRESSURE       0xD0 /**< channel pressure */
+#define MIDI_CMD_BENDER                 0xE0 /**< pitch bender */
+
+#define MIDI_CMD_COMMON_SYSEX           0xF0 /**< sysex (system exclusive) begin */
+#define MIDI_CMD_COMMON_MTC_QUARTER     0xF1 /**< MTC quarter frame */
+#define MIDI_CMD_COMMON_SONG_POS        0xF2 /**< song position */
+#define MIDI_CMD_COMMON_SONG_SELECT     0xF3 /**< song select */
+#define MIDI_CMD_COMMON_TUNE_REQUEST    0xF6 /**< tune request */
+#define MIDI_CMD_COMMON_SYSEX_END       0xF7 /**< end of sysex */
+#define MIDI_CMD_COMMON_CLOCK           0xF8 /**< clock */
+#define MIDI_CMD_COMMON_TICK            0xF9 /**< tick */
+#define MIDI_CMD_COMMON_START           0xFA /**< start */
+#define MIDI_CMD_COMMON_CONTINUE        0xFB /**< continue */
+#define MIDI_CMD_COMMON_STOP            0xFC /**< stop */
+#define MIDI_CMD_COMMON_SENSING         0xFE /**< active sensing */
+#define MIDI_CMD_COMMON_RESET           0xFF /**< reset */
+
+
+// Controllers:
+
+#define MIDI_CTL_MSB_BANK               0x00 /**< Bank selection */
+#define MIDI_CTL_MSB_MODWHEEL           0x01 /**< Modulation */
+#define MIDI_CTL_MSB_BREATH             0x02 /**< Breath */
+#define MIDI_CTL_MSB_FOOT               0x04 /**< Foot */
+#define MIDI_CTL_MSB_PORTAMENTO_TIME    0x05 /**< Portamento time */
+#define MIDI_CTL_MSB_DATA_ENTRY         0x06 /**< Data entry */
+#define MIDI_CTL_MSB_MAIN_VOLUME        0x07 /**< Main volume */
+#define MIDI_CTL_MSB_BALANCE            0x08 /**< Balance */
+#define MIDI_CTL_MSB_PAN                0x0A /**< Panpot */
+#define MIDI_CTL_MSB_EXPRESSION         0x0B /**< Expression */
+#define MIDI_CTL_MSB_EFFECT1            0x0C /**< Effect1 */
+#define MIDI_CTL_MSB_EFFECT2            0x0D /**< Effect2 */
+#define MIDI_CTL_MSB_GENERAL_PURPOSE1   0x10 /**< General purpose 1 */
+#define MIDI_CTL_MSB_GENERAL_PURPOSE2   0x11 /**< General purpose 2 */
+#define MIDI_CTL_MSB_GENERAL_PURPOSE3   0x12 /**< General purpose 3 */
+#define MIDI_CTL_MSB_GENERAL_PURPOSE4   0x13 /**< General purpose 4 */
+#define MIDI_CTL_LSB_BANK               0x20 /**< Bank selection */
+#define MIDI_CTL_LSB_MODWHEEL           0x21 /**< Modulation */
+#define MIDI_CTL_LSB_BREATH             0x22 /**< Breath */
+#define MIDI_CTL_LSB_FOOT               0x24 /**< Foot */
+#define MIDI_CTL_LSB_PORTAMENTO_TIME    0x25 /**< Portamento time */
+#define MIDI_CTL_LSB_DATA_ENTRY         0x26 /**< Data entry */
+#define MIDI_CTL_LSB_MAIN_VOLUME        0x27 /**< Main volume */
+#define MIDI_CTL_LSB_BALANCE            0x28 /**< Balance */
+#define MIDI_CTL_LSB_PAN                0x2A /**< Panpot */
+#define MIDI_CTL_LSB_EXPRESSION         0x2B /**< Expression */
+#define MIDI_CTL_LSB_EFFECT1            0x2C /**< Effect1 */
+#define MIDI_CTL_LSB_EFFECT2            0x2D /**< Effect2 */
+#define MIDI_CTL_LSB_GENERAL_PURPOSE1   0x30 /**< General purpose 1 */
+#define MIDI_CTL_LSB_GENERAL_PURPOSE2   0x31 /**< General purpose 2 */
+#define MIDI_CTL_LSB_GENERAL_PURPOSE3   0x32 /**< General purpose 3 */
+#define MIDI_CTL_LSB_GENERAL_PURPOSE4   0x33 /**< General purpose 4 */
+#define MIDI_CTL_SUSTAIN                0x40 /**< Sustain pedal */
+#define MIDI_CTL_PORTAMENTO             0x41 /**< Portamento */
+#define MIDI_CTL_SOSTENUTO              0x42 /**< Sostenuto */
+#define MIDI_CTL_SUSTENUTO              0x42 /**< Sostenuto (a typo in the older version) */
+#define MIDI_CTL_SOFT_PEDAL             0x43 /**< Soft pedal */
+#define MIDI_CTL_LEGATO_FOOTSWITCH      0x44 /**< Legato foot switch */
+#define MIDI_CTL_HOLD2                  0x45 /**< Hold2 */
+#define MIDI_CTL_SC1_SOUND_VARIATION    0x46 /**< SC1 Sound Variation */
+#define MIDI_CTL_SC2_TIMBRE             0x47 /**< SC2 Timbre */
+#define MIDI_CTL_SC3_RELEASE_TIME       0x48 /**< SC3 Release Time */
+#define MIDI_CTL_SC4_ATTACK_TIME        0x49 /**< SC4 Attack Time */
+#define MIDI_CTL_SC5_BRIGHTNESS         0x4A /**< SC5 Brightness */
+#define MIDI_CTL_SC6                    0x4B /**< SC6 */
+#define MIDI_CTL_SC7                    0x4C /**< SC7 */
+#define MIDI_CTL_SC8                    0x4D /**< SC8 */
+#define MIDI_CTL_SC9                    0x4E /**< SC9 */
+#define MIDI_CTL_SC10                   0x4F /**< SC10 */
+#define MIDI_CTL_GENERAL_PURPOSE5       0x50 /**< General purpose 5 */
+#define MIDI_CTL_GENERAL_PURPOSE6       0x51 /**< General purpose 6 */
+#define MIDI_CTL_GENERAL_PURPOSE7       0x52 /**< General purpose 7 */
+#define MIDI_CTL_GENERAL_PURPOSE8       0x53 /**< General purpose 8 */
+#define MIDI_CTL_PORTAMENTO_CONTROL     0x54 /**< Portamento control */
+#define MIDI_CTL_E1_REVERB_DEPTH        0x5B /**< E1 Reverb Depth */
+#define MIDI_CTL_E2_TREMOLO_DEPTH       0x5C /**< E2 Tremolo Depth */
+#define MIDI_CTL_E3_CHORUS_DEPTH        0x5D /**< E3 Chorus Depth */
+#define MIDI_CTL_E4_DETUNE_DEPTH        0x5E /**< E4 Detune Depth */
+#define MIDI_CTL_E5_PHASER_DEPTH        0x5F /**< E5 Phaser Depth */
+#define MIDI_CTL_DATA_INCREMENT         0x60 /**< Data Increment */
+#define MIDI_CTL_DATA_DECREMENT         0x61 /**< Data Decrement */
+#define MIDI_CTL_NONREG_PARM_NUM_LSB    0x62 /**< Non-registered parameter number */
+#define MIDI_CTL_NONREG_PARM_NUM_MSB    0x63 /**< Non-registered parameter number */
+#define MIDI_CTL_REGIST_PARM_NUM_LSB    0x64 /**< Registered parameter number */
+#define MIDI_CTL_REGIST_PARM_NUM_MSB    0x65 /**< Registered parameter number */
+#define MIDI_CTL_ALL_SOUNDS_OFF         0x78 /**< All sounds off */
+#define MIDI_CTL_RESET_CONTROLLERS      0x79 /**< Reset Controllers */
+#define MIDI_CTL_LOCAL_CONTROL_SWITCH   0x7A /**< Local control switch */
+#define MIDI_CTL_ALL_NOTES_OFF          0x7B /**< All notes off */
+#define MIDI_CTL_OMNI_OFF               0x7C /**< Omni off */
+#define MIDI_CTL_OMNI_ON                0x7D /**< Omni on */
+#define MIDI_CTL_MONO1                  0x7E /**< Mono1 */
+#define MIDI_CTL_MONO2                  0x7F /**< Mono2 */
+//@}
+
+
+/** \} */
+
+#endif /* MIDI_H */
diff --git a/libs/ardour/ardour/midi_playlist.h b/libs/ardour/ardour/midi_playlist.h
new file mode 100644
index 0000000000..44f04b781b
--- /dev/null
+++ b/libs/ardour/ardour/midi_playlist.h
@@ -0,0 +1,79 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+	Written by Dave Robillard, 2006
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+ 
+    This program 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 General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_midi_playlist_h__
+#define __ardour_midi_playlist_h__
+
+#include <vector>
+#include <list>
+
+#include <ardour/ardour.h>
+#include <ardour/playlist.h>
+
+namespace ARDOUR
+{
+
+class Session;
+class Region;
+class MidiRegion;
+class Source;
+class MidiRingBuffer;
+
+class MidiPlaylist : public ARDOUR::Playlist
+{
+public:
+	MidiPlaylist (Session&, const XMLNode&, bool hidden = false);
+	MidiPlaylist (Session&, string name, bool hidden = false);
+	MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, string name, bool hidden = false);
+	MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, nframes_t start, nframes_t cnt,
+	              string name, bool hidden = false);
+
+	~MidiPlaylist ();
+
+	nframes_t read (MidiRingBuffer& buf,
+			nframes_t start, nframes_t cnt, uint32_t chan_n=0);
+
+	int set_state (const XMLNode&);
+	UndoAction get_memento() const;
+
+	bool destroy_region (boost::shared_ptr<Region>);
+
+protected:
+
+	/* playlist "callbacks" */
+	void flush_notifications ();
+
+	void finalize_split_region (boost::shared_ptr<Region> original, boost::shared_ptr<Region> left, boost::shared_ptr<Region> right);
+	
+	void check_dependents (boost::shared_ptr<Region> region, bool norefresh);
+	void refresh_dependents (boost::shared_ptr<Region> region);
+	void remove_dependents (boost::shared_ptr<Region> region);
+
+private:
+	XMLNode& state (bool full_state);
+	void dump () const;
+
+	bool region_changed (Change, boost::shared_ptr<Region>);
+};
+
+} /* namespace ARDOUR */
+
+#endif	/* __ardour_midi_playlist_h__ */
+
+
diff --git a/libs/ardour/ardour/midi_port.h b/libs/ardour/ardour/midi_port.h
new file mode 100644
index 0000000000..f2b734a903
--- /dev/null
+++ b/libs/ardour/ardour/midi_port.h
@@ -0,0 +1,69 @@
+/*
+    Copyright (C) 2002 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: port.h 712 2006-07-28 01:08:57Z drobilla $
+*/
+
+#ifndef __ardour_midi_port_h__
+#define __ardour_midi_port_h__
+
+#include <sigc++/signal.h>
+#include <pbd/failed_constructor.h>
+#include <ardour/ardour.h>
+#include <jack/jack.h>
+#include <jack/midiport.h>
+#include <ardour/port.h>
+#include <ardour/buffer.h>
+
+namespace ARDOUR {
+
+class MidiEngine;
+
+class MidiPort : public Port {
+   public:
+	virtual ~MidiPort();
+	
+	DataType type() const { return DataType(DataType::MIDI); }
+
+	Buffer& get_buffer() {
+		return _buffer;
+	}
+
+	MidiBuffer& get_midi_buffer() {
+		return _buffer;
+	}
+	
+	void cycle_start(nframes_t nframes);
+	void cycle_end();
+
+	size_t capacity() { return _buffer.capacity(); }
+	size_t size()     { return _buffer.size(); }
+
+  protected:
+	friend class AudioEngine;
+
+	MidiPort (jack_port_t *port);
+	
+	/* engine isn't supposed to access below here */
+
+	MidiBuffer     _buffer;
+	nframes_t _nframes_this_cycle;
+};
+ 
+} // namespace ARDOUR
+
+#endif /* __ardour_midi_port_h__ */
diff --git a/libs/ardour/ardour/midi_region.h b/libs/ardour/ardour/midi_region.h
new file mode 100644
index 0000000000..200599541e
--- /dev/null
+++ b/libs/ardour/ardour/midi_region.h
@@ -0,0 +1,101 @@
+/*
+    Copyright (C) 2000-2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: midiregion.h 733 2006-08-01 17:19:38Z drobilla $
+*/
+
+#ifndef __ardour_midi_region_h__
+#define __ardour_midi_region_h__
+
+#include <vector>
+
+#include <pbd/fastlog.h>
+#include <pbd/undo.h>
+
+#include <ardour/ardour.h>
+#include <ardour/region.h>
+#include <ardour/gain.h>
+#include <ardour/logcurve.h>
+#include <ardour/export.h>
+
+class XMLNode;
+
+namespace ARDOUR {
+
+class Route;
+class Playlist;
+class Session;
+class MidiFilter;
+class MidiSource;
+class MidiRingBuffer;
+
+class MidiRegion : public Region
+{
+  public:
+	~MidiRegion();
+
+	boost::shared_ptr<MidiSource> midi_source (uint32_t n=0) const;
+
+	nframes_t read_at (MidiRingBuffer& dst,
+			nframes_t position,
+			nframes_t dur, 
+			uint32_t       chan_n      = 0,
+			nframes_t read_frames = 0,
+			nframes_t skip_frames = 0) const;
+
+	nframes_t master_read_at (MidiRingBuffer& dst,
+			nframes_t position,
+			nframes_t dur,
+			uint32_t chan_n=0) const;
+
+	XMLNode& state (bool);
+	int      set_state (const XMLNode&);
+
+	int separate_by_channel (ARDOUR::Session&, vector<MidiRegion*>&) const;
+
+	UndoAction get_memento() const;
+
+  private:
+	friend class RegionFactory;
+
+	MidiRegion (boost::shared_ptr<MidiSource>, nframes_t start, nframes_t length);
+	MidiRegion (boost::shared_ptr<MidiSource>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+	MidiRegion (SourceList &, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+	MidiRegion (boost::shared_ptr<const MidiRegion>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Region::Flag flags = Region::DefaultFlags);
+	MidiRegion (boost::shared_ptr<const MidiRegion>);
+	MidiRegion (boost::shared_ptr<MidiSource>, const XMLNode&);
+	MidiRegion (SourceList &, const XMLNode&);
+
+  private:
+	friend class Playlist;
+
+  private:
+	nframes_t _read_at (const SourceList&, MidiRingBuffer& dst,
+		nframes_t position,
+		nframes_t dur, 
+		uint32_t chan_n = 0,
+		nframes_t read_frames = 0,
+		nframes_t skip_frames = 0) const;
+
+	void recompute_at_start ();
+	void recompute_at_end ();
+};
+
+} /* namespace ARDOUR */
+
+
+#endif /* __ardour_midi_region_h__ */
diff --git a/libs/ardour/ardour/midi_ring_buffer.h b/libs/ardour/ardour/midi_ring_buffer.h
new file mode 100644
index 0000000000..71f42d7182
--- /dev/null
+++ b/libs/ardour/ardour/midi_ring_buffer.h
@@ -0,0 +1,226 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_midi_ring_buffer_h__
+#define __ardour_midi_ring_buffer_h__
+
+#include <algorithm>
+#include <ardour/types.h>
+#include <pbd/ringbufferNPT.h>
+#include <ardour/buffer.h>
+
+namespace ARDOUR {
+
+/** A MIDI RingBuffer
+ * (necessary because MIDI events are variable sized so a generic RB won't do).
+ *
+ * ALL publically accessible sizes refer to event COUNTS.  What actually goes
+ * on in here is none of the callers business :)
+ */
+class MidiRingBuffer {
+public:
+	MidiRingBuffer (size_t size)
+		: _size(size)
+		, _max_event_size(MidiBuffer::max_event_size())
+		, _ev_buf(new MidiEvent[size])
+		, _raw_buf(new RawMidi[size * _max_event_size])
+	{
+		reset ();
+		assert(read_space() == 0);
+		assert(write_space() == size - 1);
+	}
+	
+	virtual ~MidiRingBuffer() {
+		delete[] _ev_buf;
+		delete[] _raw_buf;
+	}
+
+	void reset () {
+		/* !!! NOT THREAD SAFE !!! */
+		g_atomic_int_set (&_write_ptr, 0);
+		g_atomic_int_set (&_read_ptr, 0);
+	}
+
+	size_t write_space () {
+		size_t w, r;
+		
+		w = g_atomic_int_get (&_write_ptr);
+		r = g_atomic_int_get (&_read_ptr);
+		
+		if (w > r) {
+			return ((r - w + _size) % _size) - 1;
+		} else if (w < r) {
+			return (r - w) - 1;
+		} else {
+			return _size - 1;
+		}
+	}
+	
+	size_t read_space () {
+		size_t w, r;
+		
+		w = g_atomic_int_get (&_write_ptr);
+		r = g_atomic_int_get (&_read_ptr);
+		
+		if (w > r) {
+			return w - r;
+		} else {
+			return (w - r + _size) % _size;
+		}
+	}
+
+	size_t capacity() const { return _size; }
+
+	/** Read one event and appends it to @a out. */
+	//size_t read(MidiBuffer& out);
+
+	/** Write one event (@a in) */
+	size_t write(const MidiEvent& in); // deep copies in
+
+	/** Read events all events up to time @a end into @a out, leaving stamps intact.
+	 * Any events before @a start will be dropped. */
+	size_t read(MidiBuffer& out, nframes_t start, nframes_t end);
+
+	/** Write all events from @a in, applying @a offset to all time stamps */
+	size_t write(const MidiBuffer& in, nframes_t offset = 0);
+
+	inline void clear_event(size_t index);
+
+private:
+
+	// _event_ indices
+	mutable gint _write_ptr;
+	mutable gint _read_ptr;
+	
+	size_t     _size;           // size (capacity) in events
+	size_t     _max_event_size; // ratio of raw_buf size to ev_buf size
+	MidiEvent* _ev_buf;         // these point into...
+	RawMidi*   _raw_buf;        // this
+
+};
+
+/** Just for sanity checking */
+inline void
+MidiRingBuffer::clear_event(size_t index)
+{
+	memset(&_ev_buf[index].buffer, 0, _max_event_size);
+	_ev_buf[index].time = 0;
+	_ev_buf[index].size = 0;
+	_ev_buf[index].buffer = 0;
+
+}
+
+inline size_t
+MidiRingBuffer::write (const MidiEvent& ev)
+{
+	//static nframes_t last_write_time = 0;
+	
+	assert(ev.size > 0);
+
+	size_t priv_write_ptr = g_atomic_int_get(&_write_ptr);
+
+	if (write_space () == 0) {
+		return 0;
+	} else {
+		//assert(ev.time >= last_write_time);
+
+		const size_t raw_index = priv_write_ptr * _max_event_size;
+
+		MidiEvent* const write_ev = &_ev_buf[priv_write_ptr];
+		*write_ev = ev;
+
+		memcpy(&_raw_buf[raw_index], ev.buffer, ev.size);
+		write_ev->buffer = &_raw_buf[raw_index];
+        g_atomic_int_set(&_write_ptr, (priv_write_ptr + 1) % _size);
+		
+		//printf("MRB - wrote %xd %d %d with time %u at index %zu (raw index %zu)\n",
+		//	write_ev->buffer[0], write_ev->buffer[1], write_ev->buffer[2], write_ev->time,
+		//	priv_write_ptr, raw_index);
+		
+		assert(write_ev->size = ev.size);
+
+		//last_write_time = ev.time;
+		//printf("(W) read space: %zu\n", read_space());
+
+		return 1;
+	}
+}
+
+inline size_t
+MidiRingBuffer::read(MidiBuffer& dst, nframes_t start, nframes_t end)
+{
+	if (read_space() == 0)
+		return 0;
+
+	size_t         priv_read_ptr = g_atomic_int_get(&_read_ptr);
+	nframes_t time          = _ev_buf[priv_read_ptr].time;
+	size_t         count         = 0;
+	size_t         limit         = read_space();
+
+	while (time <= end && limit > 0) {
+		MidiEvent* const read_ev = &_ev_buf[priv_read_ptr];
+		if (time >= start) {
+			dst.push_back(*read_ev);
+			//printf("MRB - read %#X %d %d with time %u at index %zu\n",
+			//	read_ev->buffer[0], read_ev->buffer[1], read_ev->buffer[2], read_ev->time,
+			//	priv_read_ptr);
+		} else {
+			printf("MRB - SKIPPING - %#X %d %d with time %u at index %zu\n",
+				read_ev->buffer[0], read_ev->buffer[1], read_ev->buffer[2], read_ev->time,
+				priv_read_ptr);
+			break;
+		}
+
+		clear_event(priv_read_ptr);
+
+		++count;
+		--limit;
+		
+		priv_read_ptr = (priv_read_ptr + 1) % _size;
+		
+		assert(read_ev->time <= end);
+		time = _ev_buf[priv_read_ptr].time;
+	}
+	
+	g_atomic_int_set(&_read_ptr, priv_read_ptr);
+	
+	//printf("(R) read space: %zu\n", read_space());
+
+	return count;
+}
+
+inline size_t
+MidiRingBuffer::write(const MidiBuffer& in, nframes_t offset)
+{
+	size_t num_events = in.size();
+	size_t to_write = std::min(write_space(), num_events);
+
+	// FIXME: double copy :/
+	for (size_t i=0; i < to_write; ++i) {
+		MidiEvent ev = in[i];
+		ev.time += offset;
+		write(ev);
+	}
+
+	return to_write;
+}
+
+} // namespace ARDOUR
+
+#endif // __ardour_midi_ring_buffer_h__
+
diff --git a/libs/ardour/ardour/midi_source.h b/libs/ardour/ardour/midi_source.h
new file mode 100644
index 0000000000..5504db6ab6
--- /dev/null
+++ b/libs/ardour/ardour/midi_source.h
@@ -0,0 +1,87 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+	Written by Dave Robillard, 2006
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_midi_source_h__
+#define __ardour_midi_source_h__
+
+#include <string>
+
+#include <time.h>
+
+#include <glibmm/thread.h>
+
+#include <sigc++/signal.h>
+
+#include <ardour/source.h>
+#include <ardour/ardour.h>
+#include <pbd/stateful.h>
+#include <pbd/xml++.h>
+
+using std::string;
+
+namespace ARDOUR {
+
+class MidiRingBuffer;
+
+/** Source for MIDI data */
+class MidiSource : public Source
+{
+  public:
+	MidiSource (Session& session, string name);
+	MidiSource (Session& session, const XMLNode&);
+	virtual ~MidiSource ();
+	
+	virtual nframes_t read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const;
+	virtual nframes_t write (MidiRingBuffer& src, nframes_t cnt);
+
+	virtual void mark_for_remove() = 0;
+	virtual void mark_streaming_write_completed () {}
+
+	string captured_for() const { return _captured_for; }
+	void   set_captured_for (string str) { _captured_for = str; }
+
+	uint32_t read_data_count()  const { return _read_data_count; }
+	uint32_t write_data_count() const { return _write_data_count; }
+
+	static sigc::signal<void,MidiSource*> MidiSourceCreated;
+	       
+	// The MIDI equivalent to "peaks"
+	static int  start_view_data_thread ();
+	static void stop_view_data_thread ();
+	mutable sigc::signal<void,nframes_t,nframes_t> ViewDataRangeReady;
+	
+	XMLNode& get_state ();
+	int set_state (const XMLNode&);
+
+  protected:
+	virtual nframes_t read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const = 0;
+	virtual nframes_t write_unlocked (MidiRingBuffer& dst, nframes_t cnt) = 0;
+	
+	mutable Glib::Mutex _lock;
+	string              _captured_for;
+	mutable uint32_t    _read_data_count;  ///< modified in read()
+	mutable uint32_t    _write_data_count; ///< modified in write()
+
+  private:
+	bool file_changed (string path);
+};
+
+}
+
+#endif /* __ardour_midi_source_h__ */
diff --git a/libs/ardour/ardour/midi_track.h b/libs/ardour/ardour/midi_track.h
new file mode 100644
index 0000000000..0dad40a973
--- /dev/null
+++ b/libs/ardour/ardour/midi_track.h
@@ -0,0 +1,88 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+	Written by Dave Robillard
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+ 
+    This program 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 General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_midi_track_h__
+#define __ardour_midi_track_h__
+
+#include <ardour/track.h>
+
+namespace ARDOUR
+{
+
+class Session;
+class MidiDiskstream;
+class MidiPlaylist;
+class RouteGroup;
+
+class MidiTrack : public Track
+{
+public:
+	MidiTrack (Session&, string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal);
+	MidiTrack (Session&, const XMLNode&);
+	~MidiTrack ();
+	
+	int set_name (string str, void *src);
+
+	int roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+		nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
+	
+	int no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+		nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
+	
+	int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+		nframes_t offset, bool can_record, bool rec_monitors_input);
+
+	void process_output_buffers (BufferSet& bufs,
+				     nframes_t start_frame, nframes_t end_frame,
+				     nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
+				     bool meter);
+
+	boost::shared_ptr<MidiDiskstream> midi_diskstream() const;
+
+	int use_diskstream (string name);
+	int use_diskstream (const PBD::ID& id);
+
+	int set_mode (TrackMode m);
+
+	void set_latency_delay (nframes_t);
+
+	int export_stuff (BufferSet& bufs,
+		nframes_t nframes, nframes_t end_frame);
+
+	void freeze (InterThreadInfo&);
+	void unfreeze ();
+
+	void bounce (InterThreadInfo&);
+	void bounce_range (nframes_t start, nframes_t end, InterThreadInfo&);
+
+	int set_state(const XMLNode& node);
+
+protected:
+	XMLNode& state (bool full);
+
+private:
+	int set_diskstream (boost::shared_ptr<MidiDiskstream> ds);
+
+	void set_state_part_two ();
+	void set_state_part_three ();
+};
+
+} /* namespace ARDOUR*/
+
+#endif /* __ardour_midi_track_h__ */
diff --git a/libs/ardour/ardour/midi_util.h b/libs/ardour/ardour/midi_util.h
new file mode 100644
index 0000000000..d85ab128fe
--- /dev/null
+++ b/libs/ardour/ardour/midi_util.h
@@ -0,0 +1,72 @@
+/*
+    Copyright (C) 2006 Paul Davis
+	Written by Dave Robillard, 2006
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#ifndef __ardour_midi_util_h__ 
+#define __ardour_midi_util_h__
+
+#include <ardour/midi_events.h>
+
+namespace ARDOUR {
+
+/** Return the size of the given event NOT including the status byte,
+ * or -1 if unknown (eg sysex)
+ */
+int
+midi_event_size(unsigned char status)
+{
+	if (status >= 0x80 && status <= 0xE0) {
+		status &= 0xF0; // mask off the channel
+	}
+
+	switch (status) {
+		case MIDI_CMD_NOTE_OFF:
+		case MIDI_CMD_NOTE_ON:
+		case MIDI_CMD_NOTE_PRESSURE:
+		case MIDI_CMD_CONTROL:
+		case MIDI_CMD_BENDER:
+		case MIDI_CMD_COMMON_SONG_POS:
+			return 2;
+
+		case MIDI_CMD_PGM_CHANGE:
+		case MIDI_CMD_CHANNEL_PRESSURE:
+		case MIDI_CMD_COMMON_MTC_QUARTER:
+		case MIDI_CMD_COMMON_SONG_SELECT:
+			return 1;
+
+		case MIDI_CMD_COMMON_TUNE_REQUEST:
+		case MIDI_CMD_COMMON_SYSEX_END:
+		case MIDI_CMD_COMMON_CLOCK:
+		case MIDI_CMD_COMMON_START:
+		case MIDI_CMD_COMMON_CONTINUE:
+		case MIDI_CMD_COMMON_STOP:
+		case MIDI_CMD_COMMON_SENSING:
+		case MIDI_CMD_COMMON_RESET:
+			return 0;
+		
+		case MIDI_CMD_COMMON_SYSEX:
+			return -1;
+	}
+
+	return -1;
+}
+
+} // namespace ARDOUR
+
+#endif /* __ardour_midi_util_h__ */
diff --git a/libs/ardour/ardour/mix.h b/libs/ardour/ardour/mix.h
index 5555f5437e..67779f0e07 100644
--- a/libs/ardour/ardour/mix.h
+++ b/libs/ardour/ardour/mix.h
@@ -27,53 +27,39 @@
 
 extern "C" {
 /* SSE functions */
-	float x86_sse_compute_peak		(ARDOUR::Sample *buf, nframes_t nsamples, float current);
-
-	void  x86_sse_apply_gain_to_buffer	(ARDOUR::Sample *buf, nframes_t nframes, float gain);
-
-	void  x86_sse_mix_buffers_with_gain	(ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
-
-	void  x86_sse_mix_buffers_no_gain	(ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
+	float x86_sse_compute_peak		(const ARDOUR::Sample * buf, nframes_t nsamples, float current);
+	void  x86_sse_apply_gain_to_buffer	(ARDOUR::Sample * buf, nframes_t nframes, float gain);
+	void  x86_sse_mix_buffers_with_gain	(ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
+	void  x86_sse_mix_buffers_no_gain	(ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
 }
 
-void x86_sse_find_peaks                        (ARDOUR::Sample *buf, nframes_t nsamples, float *min, float *max);
+void  x86_sse_find_peaks                (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max);
 
 /* debug wrappers for SSE functions */
 
-float debug_compute_peak		(ARDOUR::Sample *buf, nframes_t nsamples, float current);
-
-void  debug_apply_gain_to_buffer	(ARDOUR::Sample *buf, nframes_t nframes, float gain);
-
-void  debug_mix_buffers_with_gain	(ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
-
-void  debug_mix_buffers_no_gain		(ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
+float debug_compute_peak		(const ARDOUR::Sample * buf, nframes_t nsamples, float current);
+void  debug_apply_gain_to_buffer	(ARDOUR::Sample * buf, nframes_t nframes, float gain);
+void  debug_mix_buffers_with_gain	(ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
+void  debug_mix_buffers_no_gain		(ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
 
 #endif
 
 #if defined (__APPLE__)
 
-float veclib_compute_peak              (ARDOUR::Sample *buf, nframes_t nsamples, float current);
-
-void veclib_find_peaks                (ARDOUR::Sample *buf, nframes_t nsamples, float *min, float *max);
-
-void  veclib_apply_gain_to_buffer      (ARDOUR::Sample *buf, nframes_t nframes, float gain);
-
-void  veclib_mix_buffers_with_gain     (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
-
-void  veclib_mix_buffers_no_gain       (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
+float veclib_compute_peak              (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
+void veclib_find_peaks                 (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max);
+void  veclib_apply_gain_to_buffer      (ARDOUR::Sample * buf, nframes_t nframes, float gain);
+void  veclib_mix_buffers_with_gain     (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
+void  veclib_mix_buffers_no_gain       (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
 
 #endif
 
 /* non-optimized functions */
 
-float compute_peak              (ARDOUR::Sample *buf, nframes_t nsamples, float current);
-
-void  find_peaks                (ARDOUR::Sample *buf, nframes_t nsamples, float *min, float *max);
-
-void  apply_gain_to_buffer      (ARDOUR::Sample *buf, nframes_t nframes, float gain);
-
-void  mix_buffers_with_gain     (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain);
-
-void  mix_buffers_no_gain       (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes);
+float default_compute_peak              (const ARDOUR::Sample * buf, nframes_t nsamples, float current);
+void  default_find_peaks                (const ARDOUR::Sample * buf, nframes_t nsamples, float *min, float *max);
+void  default_apply_gain_to_buffer      (ARDOUR::Sample * buf, nframes_t nframes, float gain);
+void  default_mix_buffers_with_gain     (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain);
+void  default_mix_buffers_no_gain       (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes);
 
 #endif /* __ardour_mix_h__ */
diff --git a/libs/ardour/ardour/panner.h b/libs/ardour/ardour/panner.h
index a4a1d5d3b9..9d6a7e7fb6 100644
--- a/libs/ardour/ardour/panner.h
+++ b/libs/ardour/ardour/panner.h
@@ -39,6 +39,8 @@ namespace ARDOUR {
 
 class Session;
 class Panner;
+class BufferSet;
+class AudioBuffer;
 
 class StreamPanner : public sigc::trackable, public Stateful
 {
@@ -61,10 +63,10 @@ class StreamPanner : public sigc::trackable, public Stateful
 	void get_effective_position (float& xpos, float& ypos) const { xpos = effective_x; ypos = effective_y; }
 	void get_effective_position (float& xpos, float& ypos, float& zpos) const { xpos = effective_x; ypos = effective_y; zpos = effective_z; }
 
-	/* the basic panner API */
+	/* the basic StreamPanner API */
 
-	virtual void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes) = 0;
-	virtual void distribute_automated (Sample* src, Sample** obufs, 
+	virtual void distribute (AudioBuffer& src, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes) = 0;
+	virtual void distribute_automated (AudioBuffer& src, BufferSet& obufs,
 				     nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers) = 0;
 
 	/* automation */
@@ -140,7 +142,7 @@ class BaseStereoPanner : public StreamPanner
 	   and a type name. See EqualPowerStereoPanner as an example.
 	*/
 
-	void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes);
+	void distribute (AudioBuffer& src, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes);
 
 	void snapshot (nframes_t now);
 	void transport_stopped (nframes_t frame);
@@ -170,7 +172,7 @@ class EqualPowerStereoPanner : public BaseStereoPanner
 	EqualPowerStereoPanner (Panner&);
 	~EqualPowerStereoPanner ();
 
-	void distribute_automated (Sample* src, Sample** obufs, 
+	void distribute_automated (AudioBuffer& src, BufferSet& obufs, 
 			     nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers);
 
 	void get_current_coefficients (pan_t*) const;
@@ -204,8 +206,8 @@ class Multi2dPanner : public StreamPanner
 
 	Curve& automation() { return _automation; }
 
-	void distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes);
-	void distribute_automated (Sample* src, Sample** obufs, 
+	void distribute (AudioBuffer& src, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes);
+	void distribute_automated (AudioBuffer& src, BufferSet& obufs,
 				   nframes_t start, nframes_t end, nframes_t nframes, pan_t** buffers);
 
 	static StreamPanner* factory (Panner&);
@@ -241,6 +243,9 @@ class Panner : public std::vector<StreamPanner*>, public Stateful, public sigc::
 	Panner (string name, Session&);
 	virtual ~Panner ();
 
+	/// The fundamental Panner function
+	void distribute(BufferSet& src, BufferSet& dest, nframes_t start_frame, nframes_t end_frames, nframes_t nframes, nframes_t offset);
+
 	bool bypassed() const { return _bypassed; }
 	void set_bypassed (bool yn);
 
@@ -302,6 +307,7 @@ class Panner : public std::vector<StreamPanner*>, public Stateful, public sigc::
 	int load ();
 
   private:
+	void distribute_no_automation(BufferSet& src, BufferSet& dest, nframes_t nframes, nframes_t offset, gain_t gain_coeff);
 
 	Session&         _session;
 	uint32_t     current_outs;
diff --git a/libs/ardour/ardour/peak.h b/libs/ardour/ardour/peak.h
index eaeafe0f5d..bbec40eea7 100644
--- a/libs/ardour/ardour/peak.h
+++ b/libs/ardour/ardour/peak.h
@@ -25,7 +25,7 @@
 #include <ardour/utils.h>
 
 static inline float
-compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current) 
+default_compute_peak (const ARDOUR::Sample * const buf, nframes_t nsamples, float current) 
 {
 	for (nframes_t i = 0; i < nsamples; ++i) {
 		current = f_max (current, fabsf (buf[i]));
diff --git a/libs/ardour/ardour/playlist.h b/libs/ardour/ardour/playlist.h
index 5f33719ae7..b1612f39d5 100644
--- a/libs/ardour/ardour/playlist.h
+++ b/libs/ardour/ardour/playlist.h
@@ -40,6 +40,7 @@
 #include <ardour/ardour.h>
 #include <ardour/crossfade_compare.h>
 #include <ardour/location.h>
+#include <ardour/data_type.h>
 
 namespace ARDOUR  {
 
@@ -50,8 +51,8 @@ class Playlist : public PBD::StatefulDestructible, public boost::enable_shared_f
   public:
 	typedef list<boost::shared_ptr<Region> >    RegionList;
 
-	Playlist (Session&, const XMLNode&, bool hidden = false);
-	Playlist (Session&, string name, bool hidden = false);
+	Playlist (Session&, const XMLNode&, DataType type, bool hidden = false);
+	Playlist (Session&, string name, DataType type, bool hidden = false);
 	Playlist (boost::shared_ptr<const Playlist>, string name, bool hidden = false);
 	Playlist (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
 
@@ -69,6 +70,8 @@ class Playlist : public PBD::StatefulDestructible, public boost::enable_shared_f
 	std::string name() const { return _name; }
 	void set_name (std::string str);
 
+	const DataType& data_type() const { return _type; }
+
 	bool frozen() const { return _frozen; }
 	void set_frozen (bool yn);
 
@@ -171,6 +174,7 @@ class Playlist : public PBD::StatefulDestructible, public boost::enable_shared_f
 	std::set<boost::shared_ptr<Region> > all_regions; /* all regions ever added to this playlist */
 	string          _name;
 	Session&        _session;
+	DataType        _type;
 	mutable gint    block_notifications;
 	mutable gint    ignore_state_changes;
 	mutable Glib::Mutex region_lock;
diff --git a/libs/ardour/ardour/playlist_factory.h b/libs/ardour/ardour/playlist_factory.h
index be7c290a8c..a28e2611d9 100644
--- a/libs/ardour/ardour/playlist_factory.h
+++ b/libs/ardour/ardour/playlist_factory.h
@@ -34,7 +34,7 @@ class PlaylistFactory {
 	static sigc::signal<void,boost::shared_ptr<Playlist> > PlaylistCreated;
 
 	static boost::shared_ptr<Playlist> create (Session&, const XMLNode&, bool hidden = false);
-	static boost::shared_ptr<Playlist> create (Session&, string name, bool hidden = false);
+	static boost::shared_ptr<Playlist> create (DataType type, Session&, string name, bool hidden = false);
 	static boost::shared_ptr<Playlist> create (boost::shared_ptr<const Playlist>, string name, bool hidden = false);
 	static boost::shared_ptr<Playlist> create (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
 };
diff --git a/libs/ardour/ardour/plugin.h b/libs/ardour/ardour/plugin.h
index c7708e3690..feb86f1b7b 100644
--- a/libs/ardour/ardour/plugin.h
+++ b/libs/ardour/ardour/plugin.h
@@ -28,6 +28,7 @@
 
 #include <jack/types.h>
 #include <ardour/types.h>
+#include <ardour/plugin_state.h>
 #include <ardour/cycles.h>
 
 #include <vector>
@@ -43,6 +44,7 @@ namespace ARDOUR {
 
 class AudioEngine;
 class Session;
+class BufferSet;
 
 class Plugin;
 
@@ -116,8 +118,11 @@ class Plugin : public PBD::StatefulDestructible
 	virtual void deactivate () = 0;
 	virtual void set_block_size (nframes_t nframes) = 0;
 
-	virtual int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset) = 0;
+	virtual int connect_and_run (BufferSet& bufs, uint32_t& in, uint32_t& out, nframes_t nframes, nframes_t offset) = 0;
+	
 	virtual std::set<uint32_t> automatable() const = 0;
+	virtual void store_state (ARDOUR::PluginState&) = 0;
+	virtual void restore_state (ARDOUR::PluginState&) = 0;
 	virtual string describe_parameter (uint32_t) = 0;
 	virtual string state_node_name() const = 0;
 	virtual void print_parameter (uint32_t, char*, uint32_t len) const = 0;
diff --git a/libs/ardour/ardour/plugin_state.h b/libs/ardour/ardour/plugin_state.h
new file mode 100644
index 0000000000..bd499e2b90
--- /dev/null
+++ b/libs/ardour/ardour/plugin_state.h
@@ -0,0 +1,14 @@
+#ifndef __ardour_plugin_state_h__
+#define __ardour_plugin_state_h__
+
+#include <map>
+
+namespace ARDOUR {
+
+struct PluginState {
+    std::map<uint32_t,float> parameters;
+};
+
+} 
+
+#endif /* __ardour_plugin_state_h__ */
diff --git a/libs/ardour/ardour/port.h b/libs/ardour/ardour/port.h
index 44e9dc00a8..cae198758b 100644
--- a/libs/ardour/ardour/port.h
+++ b/libs/ardour/ardour/port.h
@@ -23,36 +23,30 @@
 #include <sigc++/signal.h>
 #include <pbd/failed_constructor.h>
 #include <ardour/ardour.h>
+#include <ardour/data_type.h>
 #include <jack/jack.h>
 
 namespace ARDOUR {
 
 class AudioEngine;
+class Buffer;
 
+/** Abstract base for all outside ports (eg Jack ports)
+ */
 class Port : public sigc::trackable {
    public:
 	virtual ~Port() { 
 		free (_port);
 	}
 
-	Sample *get_buffer (nframes_t nframes) {
-		if (_flags & JackPortIsOutput) {
-			return _buffer;
-		} else {
-			return (Sample *) jack_port_get_buffer (_port, nframes);
-		}
-	}
+	virtual DataType type() const = 0;
 
-	void reset_buffer () {
-		if (_flags & JackPortIsOutput) {
-			_buffer = (Sample *) jack_port_get_buffer (_port, 0);
-		} else {
-			_buffer = 0; /* catch illegal attempts to use it */
-		}
-		_silent = false;
-	}
+	virtual void cycle_start(nframes_t nframes) {}
+	virtual void cycle_end() {}
 
-	std::string name() { 
+	virtual Buffer& get_buffer() = 0;
+	
+	std::string name() const { 
 		return _name;
 	}
 
@@ -70,10 +64,6 @@ class Port : public sigc::trackable {
 		return jack_port_is_mine (client, _port);
 	}
 
-	const char* type() const {
-		return _type.c_str();
-	}
-
 	int connected () const {
 		return jack_port_connected (_port);
 	}
@@ -86,38 +76,6 @@ class Port : public sigc::trackable {
 		return jack_port_get_connections (_port);
 	}
 
-	void reset_overs () {
-		_short_overs = 0;
-		_long_overs = 0;
-		_overlen = 0;
-	}
-
-	void reset_peak_meter () {
-		_peak = 0;
-	}
-	
-	void reset_meters () {
-		reset_peak_meter ();
-		reset_overs ();
-	}
-
-	void enable_metering() {
-		_metering++;
-	}
-	
-	void disable_metering () {
-		if (_metering) { _metering--; }
-	}
-
-	float                       peak_db() const { return _peak_db; }
-	jack_default_audio_sample_t peak()    const { return _peak; }
-
-	uint32_t short_overs () const { return _short_overs; }
-	uint32_t long_overs ()  const { return _long_overs; }
-	
-	static void set_short_over_length (nframes_t);
-	static void set_long_over_length (nframes_t);
-
 	bool receives_input() const {
 		return _flags & JackPortIsInput;
 	}
@@ -133,6 +91,14 @@ class Port : public sigc::trackable {
 	bool can_monitor () const {
 		return _flags & JackPortCanMonitor;
 	}
+
+	void enable_metering() {
+		_metering++;
+	}
+	
+	void disable_metering () {
+		if (_metering) { _metering--; }
+	}
 	
 	void ensure_monitor_input (bool yn) {
 
@@ -160,57 +126,25 @@ class Port : public sigc::trackable {
 	sigc::signal<void,bool> MonitorInputChanged;
 	sigc::signal<void,bool> ClockSyncChanged;
 
-	bool is_silent() const { return _silent; }
-
-	/** Assumes that the port is an audio output port */
-	void silence (nframes_t nframes, nframes_t offset) {
-		if (!_silent) {
-			memset (_buffer + offset, 0, sizeof (Sample) * nframes);
-			if (offset == 0) {
-				/* XXX this isn't really true, but i am not sure
-				   how to set this correctly. we really just
-				   want to set it true when the entire port
-				   buffer has been overrwritten.
-				*/
-				_silent = true;
-			}
-		}
-	}
-	
-	void mark_silence (bool yn) {
-		_silent = yn;
-	}
-
-  private:
+  protected:
 	friend class AudioEngine;
 
 	Port (jack_port_t *port);
-	void reset ();
 	
-	/* engine isn't supposed to below here */
-
-	Sample *_buffer;
-
-	/* cache these 3 from JACK so that we can
-	   access them for reconnecting.
-	*/
+	virtual void reset ();
+	
+	/* engine isn't supposed to access below here */
 
+	/* cache these 3 from JACK so we can access them for reconnecting */
 	JackPortFlags _flags;
 	std::string   _type;
 	std::string   _name;
 
-	bool                         _last_monitor : 1;
-	bool                         _silent : 1;
-	jack_port_t                 *_port;
-	nframes_t               _overlen;
-	jack_default_audio_sample_t  _peak;
-	float                        _peak_db;
-	uint32_t                     _short_overs;
-	uint32_t                     _long_overs;
-	unsigned short               _metering;
-	
-	static nframes_t        _long_over_length;
-	static nframes_t        _short_over_length;
+	jack_port_t*  _port;
+
+	unsigned short _metering;
+
+	bool          _last_monitor : 1;
 };
  
 } // namespace ARDOUR
diff --git a/libs/ardour/ardour/port_set.h b/libs/ardour/ardour/port_set.h
new file mode 100644
index 0000000000..70edbf75fd
--- /dev/null
+++ b/libs/ardour/ardour/port_set.h
@@ -0,0 +1,164 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __ardour_port_set_h__
+#define __ardour_port_set_h__
+
+#include <vector>
+#include <ardour/port.h>
+#include <ardour/audio_port.h>
+#include <ardour/midi_port.h>
+#include <ardour/chan_count.h>
+
+namespace ARDOUR {
+
+
+/** An ordered list of Ports, possibly of various types.
+ *
+ * This allows access to all the ports as a list, ignoring type, or accessing
+ * the nth port of a given type.  Note that port(n) and nth_audio_port(n) may
+ * NOT return the same port.
+ */
+class PortSet {
+public:
+	PortSet();
+
+	size_t num_ports() const;
+	size_t num_ports(DataType type) const { return _ports[type.to_index()].size(); }
+
+	void add(Port* port);
+	bool remove(Port* port);
+
+	/** nth port */
+	Port* port(size_t index) const;
+	
+	/** nth port of type @a t, or nth port if t = NIL */
+	Port* port(DataType t, size_t index) const;
+
+	AudioPort* nth_audio_port(size_t n) const;
+	
+	MidiPort* nth_midi_port(size_t n) const;
+
+	bool contains(const Port* port) const;
+	
+	/** Remove all ports from the PortSet.  Ports are not deregistered with
+	 * the engine, it's the caller's responsibility to not leak here!
+	 */
+	void clear() { _ports.clear(); }
+
+	const ChanCount& count() const { return _count; }
+
+	bool empty() const { return (_count.get_total() == 0); }
+
+	// ITERATORS
+	
+	// FIXME: this is a filthy copy-and-paste mess
+	
+	class iterator {
+	public:
+
+		Port& operator*()  { return *_set.port(_type, _index); }
+		Port* operator->() { return _set.port(_type, _index); }
+		iterator& operator++() { ++_index; return *this; } // yes, prefix only
+		bool operator==(const iterator& other) { return (_index == other._index); }
+		bool operator!=(const iterator& other) { return (_index != other._index); }
+
+	private:
+		friend class PortSet;
+
+		iterator(PortSet& list, DataType type, size_t index)
+			: _set(list), _type(type), _index(index) {}
+
+		PortSet& _set;
+		DataType _type; ///< Ignored if NIL (to iterator over entire set)
+		size_t   _index;
+	};
+
+	iterator begin(DataType type = DataType::NIL)
+		{ return iterator(*this, type, 0); }
+	
+	iterator end(DataType type = DataType::NIL)
+	{
+		return iterator(*this, type,
+			(type == DataType::NIL) ? _count.get_total() : _count.get(type));
+	}
+	
+	// FIXME: typeify
+	class const_iterator {
+	public:
+
+		const Port& operator*()  { return *_set.port(_index); }
+		const Port* operator->() { return _set.port(_index); }
+		const_iterator& operator++() { ++_index; return *this; } // yes, prefix only
+		bool operator==(const const_iterator& other) { return (_index == other._index); }
+		bool operator!=(const const_iterator& other) { return (_index != other._index); }
+
+	private:
+		friend class PortSet;
+
+		const_iterator(const PortSet& list, size_t index) : _set(list), _index(index) {}
+
+		const PortSet& _set;
+		size_t          _index;
+	};
+
+	const_iterator begin() const { return const_iterator(*this, 0); }
+	const_iterator end()   const { return const_iterator(*this, _count.get_total()); }
+
+
+	class audio_iterator {
+	public:
+
+		AudioPort& operator*()  { return *_set.nth_audio_port(_index); }
+		AudioPort* operator->()  { return _set.nth_audio_port(_index); }
+		audio_iterator& operator++() { ++_index; return *this; } // yes, prefix only
+		bool operator==(const audio_iterator& other) { return (_index == other._index); }
+		bool operator!=(const audio_iterator& other) { return (_index != other._index); }
+
+	private:
+		friend class PortSet;
+
+		audio_iterator(PortSet& list, size_t index) : _set(list), _index(index) {}
+
+		PortSet& _set;
+		size_t    _index;
+	};
+
+	audio_iterator audio_begin() { return audio_iterator(*this, 0); }
+	audio_iterator audio_end()   { return audio_iterator(*this, _count.get(DataType::AUDIO)); }
+
+
+
+
+private:	
+	// Prevent copies (undefined)
+	PortSet(const PortSet& copy);
+	void operator=(const PortSet& other);
+
+	typedef std::vector<Port*> PortVec;
+	
+	// Vector of vectors, indexed by DataType::to_index()
+	std::vector<PortVec> _ports;
+
+	ChanCount _count;
+};
+
+
+} // namespace ARDOUR
+
+#endif // __ardour_port_set_h__
diff --git a/libs/ardour/ardour/redirect.h b/libs/ardour/ardour/redirect.h
index 6dcc105370..fac2241f14 100644
--- a/libs/ardour/ardour/redirect.h
+++ b/libs/ardour/ardour/redirect.h
@@ -61,10 +61,10 @@ class Redirect : public IO
 	bool active () const { return _active; }
 	void set_active (bool yn, void *src);
 
-	virtual uint32_t output_streams() const { return n_outputs(); }
-	virtual uint32_t input_streams () const { return n_inputs(); }
-	virtual uint32_t natural_output_streams() const { return n_outputs(); }
-	virtual uint32_t natural_input_streams () const { return n_inputs(); }
+	virtual ChanCount output_streams() const { return n_outputs(); }
+	virtual ChanCount input_streams () const { return n_inputs(); }
+	virtual ChanCount natural_output_streams() const { return n_outputs(); }
+	virtual ChanCount natural_input_streams () const { return n_inputs(); }
 
 	uint32_t sort_key() const { return _sort_key; }
 	void set_sort_key (uint32_t key);
@@ -72,7 +72,7 @@ class Redirect : public IO
 	Placement placement() const { return _placement; }
 	void set_placement (Placement, void *src);
 
-	virtual void run (vector<Sample *>& ibufs, uint32_t nbufs, nframes_t nframes, nframes_t offset) = 0;
+	virtual void run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset) = 0;
 	virtual void activate () = 0;
 	virtual void deactivate () = 0;
 	virtual nframes_t latency() { return 0; }
diff --git a/libs/ardour/ardour/region.h b/libs/ardour/ardour/region.h
index 8ab99fa151..012fd9ce96 100644
--- a/libs/ardour/ardour/region.h
+++ b/libs/ardour/ardour/region.h
@@ -20,6 +20,7 @@
 #ifndef __ardour_region_h__
 #define __ardour_region_h__
 
+#include <vector>
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
 
@@ -27,6 +28,7 @@
 #include <pbd/statefuldestructible.h> 
 
 #include <ardour/ardour.h>
+#include <ardour/data_type.h>
 
 class XMLNode;
 
@@ -43,6 +45,8 @@ enum RegionEditState {
 class Region : public PBD::StatefulDestructible, public boost::enable_shared_from_this<Region>
 {
   public:
+	typedef std::vector<boost::shared_ptr<Source> > SourceList;
+
 	enum Flag {
 		Muted = 0x1,
 		Opaque = 0x2,
@@ -85,10 +89,12 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
 	string name() const { return _name; }
 	void set_name (string str);
 
+	const DataType& data_type() const { return _type; }
+
 	nframes_t position () const { return _position; }
 	nframes_t start ()    const { return _start; }
 	nframes_t length()    const { return _length; }
-	layer_t        layer ()    const { return _layer; }
+	layer_t   layer ()    const { return _layer; }
 	
 	nframes_t sync_offset(int& dir) const;
 	nframes_t sync_position() const;
@@ -100,13 +106,14 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
 	nframes_t first_frame() const { return _position; }
 	nframes_t last_frame() const { return _position + _length - 1; }
 
+	Flag flags()      const { return _flags; }
 	bool hidden()     const { return _flags & Hidden; }
 	bool muted()      const { return _flags & Muted; }
 	bool opaque ()    const { return _flags & Opaque; }
 	bool locked()     const { return _flags & Locked; }
 	bool automatic()  const { return _flags & Automatic; }
 	bool whole_file() const { return _flags & WholeFile ; }
-	Flag flags()      const { return _flags; }
+	bool captured()   const { return !(_flags & (Region::Flag (Region::Import|Region::External))); }
 
 	virtual bool should_save_state () const { return !(_flags & DoNotSaveState); };
 
@@ -125,10 +132,8 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
 	bool size_equivalent (boost::shared_ptr<const Region>) const;
 	bool overlap_equivalent (boost::shared_ptr<const Region>) const;
 	bool region_list_equivalent (boost::shared_ptr<const Region>) const;
-	virtual bool source_equivalent (boost::shared_ptr<const Region>) const = 0;
+	bool source_equivalent (boost::shared_ptr<const Region>) const;
 	
-	virtual bool speed_mismatch (float) const = 0;
-
 	/* EDITING OPERATIONS */
 
 	void set_length (nframes_t, void *src);
@@ -164,6 +169,14 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
 	boost::shared_ptr<ARDOUR::Playlist> playlist() const { return _playlist.lock(); }
 	virtual void set_playlist (boost::weak_ptr<ARDOUR::Playlist>);
 
+	void source_deleted (boost::shared_ptr<Source>);
+	
+	boost::shared_ptr<Source> source (uint32_t n=0) const { return _sources[ (n < _sources.size()) ? n : 0 ]; }
+	uint32_t                  n_channels()          const { return _sources.size(); }
+
+	std::vector<string> master_source_names();
+
+
 	/* serialization */
 	
 	XMLNode&         get_state ();
@@ -171,7 +184,7 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
 	virtual int      set_state (const XMLNode&);
 	virtual int      set_live_state (const XMLNode&, Change&, bool send);
 
-	virtual boost::shared_ptr<Region> get_parent() const = 0;
+	virtual boost::shared_ptr<Region> get_parent() const;
 	
 	uint64_t last_layer_op() const { return _last_layer_op; }
 	void set_last_layer_op (uint64_t when);
@@ -179,12 +192,15 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
   protected:
 	friend class RegionFactory;
 
-	Region (nframes_t start, nframes_t length, 
-		const string& name, layer_t = 0, Flag flags = DefaultFlags);
+	Region (boost::shared_ptr<Source> src, nframes_t start, nframes_t length, 
+		const string& name, DataType type, layer_t = 0, Flag flags = DefaultFlags);
+	Region (SourceList& srcs, nframes_t start, nframes_t length, 
+		const string& name, DataType type, layer_t = 0, Flag flags = DefaultFlags);
+	
 	Region (boost::shared_ptr<const Region>, nframes_t start, nframes_t length, const string& name, layer_t = 0, Flag flags = DefaultFlags);
 	Region (boost::shared_ptr<const Region>);
-	Region (const XMLNode&);
-
+	Region (boost::shared_ptr<Source> src, const XMLNode&);
+	Region (SourceList& srcs, const XMLNode&);
 
   protected:
 	XMLNode& get_short_state (); /* used only by Session */
@@ -197,28 +213,33 @@ class Region : public PBD::StatefulDestructible, public boost::enable_shared_fro
 	void maybe_uncopy ();
 	void first_edit ();
 	
-	virtual bool verify_start (nframes_t) = 0;
-	virtual bool verify_start_and_length (nframes_t, nframes_t) = 0;
-	virtual bool verify_start_mutable (nframes_t&_start) = 0;
-	virtual bool verify_length (nframes_t) = 0;
+	virtual bool verify_start (nframes_t);
+	virtual bool verify_start_and_length (nframes_t, nframes_t);
+	virtual bool verify_start_mutable (nframes_t&_start);
+	virtual bool verify_length (nframes_t);
 	virtual void recompute_at_start () = 0;
 	virtual void recompute_at_end () = 0;
 	
-	
+
+	PBD::ID                 _id;
+	string                  _name;
+	DataType                _type;
+	Flag                    _flags;
 	nframes_t          _start;
 	nframes_t          _length;
 	nframes_t          _position;
-	Flag                     _flags;
 	nframes_t          _sync_position;
 	layer_t                 _layer;
-	string                  _name;        
 	mutable RegionEditState _first_edit;
 	int                     _frozen;
-	Glib::Mutex             lock;
+	mutable uint32_t        _read_data_count;  ///< modified in read()
+	Change                  _pending_changed;
+	uint64_t                _last_layer_op;  ///< timestamp
+	Glib::Mutex             _lock;
 	boost::weak_ptr<ARDOUR::Playlist> _playlist;
-	mutable uint32_t        _read_data_count; // modified in read()
-	Change                   pending_changed;
-	uint64_t                _last_layer_op; // timestamp
+	SourceList              _sources;
+	/** Used when timefx are applied, so we can always use the original source */
+	SourceList              _master_sources;
 };
 
 } /* namespace ARDOUR */
diff --git a/libs/ardour/ardour/region_factory.h b/libs/ardour/ardour/region_factory.h
index 197983a29d..e6b9e5dde6 100644
--- a/libs/ardour/ardour/region_factory.h
+++ b/libs/ardour/ardour/region_factory.h
@@ -32,14 +32,13 @@ class Session;
 class RegionFactory {
 
   public:
-	/* This is emitted only when a new id is assigned. Therefore,
+	/** This is emitted only when a new id is assigned. Therefore,
 	   in a pure Region copy, it will not be emitted.
 
 	   It must be emitted by derived classes, not Region
 	   itself, to permit dynamic_cast<> to be used to 
 	   infer the type of Region.
 	*/
-
 	static sigc::signal<void,boost::shared_ptr<Region> > CheckNewRegion;
 
 	static boost::shared_ptr<Region> create (boost::shared_ptr<Region>, nframes_t start, 
diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 442c006e9b..6247d79a27 100644
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -124,9 +124,6 @@ class Route : public IO
 
 	void set_mute_config (mute_type, bool, void *src);
 	bool get_mute_config (mute_type);
-
-	void set_phase_invert (bool yn, void *src);
-	bool phase_invert() const { return _phase_invert; }
 	
 	void       set_edit_group (RouteGroup *, void *);
 	void       drop_edit_group (void *);
@@ -161,8 +158,11 @@ class Route : public IO
 		}
 	}
 	
-	uint32_t max_redirect_outs () const { return redirect_max_outs; }
-		
+	ChanCount max_redirect_outs () const { return redirect_max_outs; }
+	
+	// FIXME: remove/replace err_streams parameters with something appropriate
+	// they are used by 'wierd_plugin_dialog'(sic) to display the number of input streams
+	// at the insertion point if the insert fails
 	int add_redirect (boost::shared_ptr<Redirect>, void *src, uint32_t* err_streams = 0);
 	int add_redirects (const RedirectList&, void *src, uint32_t* err_streams = 0);
 	int remove_redirect (boost::shared_ptr<Redirect>, void *src, uint32_t* err_streams = 0);
@@ -257,7 +257,6 @@ class Route : public IO
 	bool                     _muted : 1;
 	bool                     _soloed : 1;
 	bool                     _solo_safe : 1;
-	bool                     _phase_invert : 1;
 	bool                     _recordable : 1;
 	bool                     _active : 1;
 	bool                     _mute_affects_pre_fader : 1;
@@ -295,24 +294,28 @@ class Route : public IO
 	void passthru (nframes_t start_frame, nframes_t end_frame, 
 		       nframes_t nframes, nframes_t offset, int declick, bool meter_inputs);
 
-	void process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
+	virtual void process_output_buffers (BufferSet& bufs,
 				     nframes_t start_frame, nframes_t end_frame,
 				     nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
 				     bool meter);
 
   protected:
-	/* for derived classes */
 
 	virtual XMLNode& state(bool);
 
+	void passthru_silence (nframes_t start_frame, nframes_t end_frame,
+	                       nframes_t nframes, nframes_t offset, int declick,
+	                       bool meter);
+	
 	void silence (nframes_t nframes, nframes_t offset);
+	
 	sigc::connection input_signal_connection;
 
-	uint32_t redirect_max_outs;
+	ChanCount redirect_max_outs;
 	uint32_t _remote_control_id;
 
 	uint32_t pans_required() const;
-	uint32_t n_process_buffers ();
+	ChanCount n_process_buffers ();
 
 	virtual int _set_state (const XMLNode&, bool call_base);
 
diff --git a/libs/ardour/ardour/runtime_functions.h b/libs/ardour/ardour/runtime_functions.h
new file mode 100644
index 0000000000..c1dab4ebc7
--- /dev/null
+++ b/libs/ardour/ardour/runtime_functions.h
@@ -0,0 +1,40 @@
+/*
+    Copyright (C) 2007 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#ifndef __ardour_runtime_functions_h__
+#define __ardour_runtime_functions_h__
+
+#include <ardour/types.h>
+
+namespace ARDOUR {
+
+	typedef float (*compute_peak_t)			(const ARDOUR::Sample *, nframes_t, float);
+	typedef void  (*find_peaks_t)                   (const ARDOUR::Sample *, nframes_t, float *, float*);
+	typedef void  (*apply_gain_to_buffer_t)		(ARDOUR::Sample *, nframes_t, float);
+	typedef void  (*mix_buffers_with_gain_t)	(ARDOUR::Sample *, const ARDOUR::Sample *, nframes_t, float);
+	typedef void  (*mix_buffers_no_gain_t)		(ARDOUR::Sample *, const ARDOUR::Sample *, nframes_t);
+
+	extern compute_peak_t		compute_peak;
+	extern find_peaks_t             find_peaks;
+	extern apply_gain_to_buffer_t	apply_gain_to_buffer;
+	extern mix_buffers_with_gain_t	mix_buffers_with_gain;
+	extern mix_buffers_no_gain_t	mix_buffers_no_gain;
+}
+
+#endif /* __ardour_runtime_functions_h__ */
diff --git a/libs/ardour/ardour/send.h b/libs/ardour/ardour/send.h
index 92e4fdade2..4e3c0fbe2d 100644
--- a/libs/ardour/ardour/send.h
+++ b/libs/ardour/ardour/send.h
@@ -42,7 +42,8 @@ class Send : public Redirect
 
 	uint32_t bit_slot() const { return bitslot; }
 	
-	void run (vector<Sample *> &bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset);
+	void run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset);
+	
 	void activate() {}
 	void deactivate () {}
 
@@ -52,14 +53,14 @@ class Send : public Redirect
 	XMLNode& get_state(void);
 	int set_state(const XMLNode& node);
 
-	uint32_t pans_required() const { return expected_inputs; }
-	void expect_inputs (uint32_t);
+	uint32_t pans_required() const { return _expected_inputs.get(DataType::AUDIO); }
+	void expect_inputs (const ChanCount&);
 
 	static uint32_t how_many_sends();
 
   private:
-	bool _metering;
-	uint32_t expected_inputs;
+	bool      _metering;
+	ChanCount _expected_inputs;
 	uint32_t bitslot;
 };
 
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 70a9d7c96f..f3e8d73de0 100644
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -20,7 +20,6 @@
 #ifndef __ardour_session_h__
 #define __ardour_session_h__
 
-
 #include <string>
 #include <list>
 #include <map>
@@ -55,6 +54,8 @@
 #include <ardour/gain.h>
 #include <ardour/io.h>
 
+#include <ardour/smpte.h>
+
 class XMLTree;
 class XMLNode;
 class AEffect;
@@ -72,13 +73,18 @@ namespace ARDOUR {
 class Port;
 class AudioEngine;
 class Slave;
-class Diskstream;	
-class AudioDiskstream;	
+class Diskstream;
 class Route;
 class AuxInput;
 class Source;
 class AudioSource;
+class BufferSet;
+
+class Diskstream;
+class AudioDiskstream;
+class MidiDiskstream;
 class AudioFileSource;
+class MidiSource;
 class Auditioner;
 class Insert;
 class Send;
@@ -90,11 +96,16 @@ class TempoMap;
 class AudioTrack;
 class NamedSelection;
 class AudioRegion;
+
 class Region;
 class Playlist;
 class VSTPlugin;
 class ControlProtocolInfo;
 
+class MidiTrack;
+class MidiRegion;
+class SMFSource;
+
 struct AudioExportSpecification;
 struct RouteGroup;
 
@@ -104,7 +115,6 @@ using std::map;
 using std::set;
 
 class Session : public PBD::StatefulDestructible
-
 {
   private:
 	typedef std::pair<boost::weak_ptr<Route>,bool> RouteBooleanState;
@@ -151,8 +161,8 @@ class Session : public PBD::StatefulDestructible
 		    Replace,
 		    Clear
 	    };
-
-	    Type           type;
+		
+		Type           type;
 	    Action         action;
 	    nframes_t action_frame;
 	    nframes_t target_frame;
@@ -162,6 +172,7 @@ class Session : public PBD::StatefulDestructible
 			void*                ptr;
 			bool                 yes_or_no;
 			SlaveSource slave;
+			Route*               route;
 	    };
 
 	    boost::shared_ptr<Region>     region;
@@ -252,8 +263,6 @@ class Session : public PBD::StatefulDestructible
 	std::string dead_sound_dir () const;
 	std::string automation_dir () const;
 
-	string peak_path_from_audio_path (string) const;
-
 	static string suffixed_search_path (std::string suffix, bool data);
 	static string control_protocol_path ();
 	static string template_path ();
@@ -261,14 +270,18 @@ class Session : public PBD::StatefulDestructible
 	static void get_template_list (list<string>&);
 	
 	static string change_audio_path_by_name (string oldpath, string oldname, string newname, bool destructive);
+	static string change_midi_path_by_name (string oldpath, string oldname, string newname, bool destructive);
+	
+	string peak_path_from_audio_path (string) const;
 	string audio_path_from_name (string, uint32_t nchans, uint32_t chan, bool destructive);
+	string midi_path_from_name (string);
 
 	void process (nframes_t nframes);
 
-	vector<Sample*>& get_passthru_buffers() { return _passthru_buffers; }
-	vector<Sample*>& get_silent_buffers (uint32_t howmany);
-	vector<Sample*>& get_send_buffers () { return _send_buffers; }
-
+	BufferSet& get_silent_buffers (ChanCount count = ChanCount::ZERO);
+	BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO);
+	BufferSet& get_send_buffers (ChanCount count = ChanCount::ZERO);
+	
 	void add_diskstream (boost::shared_ptr<Diskstream>);
 	boost::shared_ptr<Diskstream> diskstream_by_id (const PBD::ID& id);
 	boost::shared_ptr<Diskstream> diskstream_by_name (string name);
@@ -283,11 +296,11 @@ class Session : public PBD::StatefulDestructible
 	
 	typedef std::list<boost::shared_ptr<Diskstream> > DiskstreamList;
 	typedef std::list<boost::shared_ptr<Route> >      RouteList; 
-
+	
 	boost::shared_ptr<RouteList> get_routes() const {
 		return routes.reader ();
 	}
-
+	
 	uint32_t nroutes() const { return routes.reader()->size(); }
 	uint32_t ntracks () const;
 	uint32_t nbusses () const;
@@ -370,6 +383,7 @@ class Session : public PBD::StatefulDestructible
 	bool transport_locked () const;
 
 	int wipe ();
+	//int wipe_diskstream (AudioDiskstream *);
 
 	int remove_region_from_region_list (boost::shared_ptr<Region>);
 
@@ -474,12 +488,14 @@ class Session : public PBD::StatefulDestructible
 
 	std::list<boost::shared_ptr<AudioTrack> > new_audio_track (int input_channels, int output_channels, TrackMode mode = Normal, uint32_t how_many = 1);
 	RouteList new_audio_route (int input_channels, int output_channels, uint32_t how_many);
+	
+	std::list<boost::shared_ptr<MidiTrack> > new_midi_track (TrackMode mode = Normal, uint32_t how_many = 1);
+	//boost::shared_ptr<Route>     new_midi_route (uint32_t how_many = 1);
 
 	void   remove_route (boost::shared_ptr<Route>);
-
 	void   resort_routes ();
 	void   resort_routes_using (boost::shared_ptr<RouteList>);
-
+	
 	void	set_remote_control_ids();
 
 	AudioEngine &engine() { return _engine; };
@@ -541,19 +557,22 @@ class Session : public PBD::StatefulDestructible
 	
 	/* region info  */
 
-	sigc::signal<void,boost::weak_ptr<AudioRegion> > AudioRegionAdded;
-	sigc::signal<void,boost::weak_ptr<AudioRegion> > AudioRegionRemoved;
+	sigc::signal<void,boost::shared_ptr<Region> > RegionAdded;
+	sigc::signal<void,boost::shared_ptr<Region> > RegionRemoved;
 
 	int region_name (string& result, string base = string(""), bool newlevel = false) const;
 	string new_region_name (string);
 	string path_from_region_name (string name, string identifier);
 
-	boost::shared_ptr<AudioRegion> find_whole_file_parent (boost::shared_ptr<AudioRegion const>);
+	boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>);
+	
 	void find_equivalent_playlist_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >& result);
 
-	boost::shared_ptr<AudioRegion> XMLRegionFactory (const XMLNode&, bool full);
+	boost::shared_ptr<Region>      XMLRegionFactory (const XMLNode&, bool full);
+	boost::shared_ptr<AudioRegion> XMLAudioRegionFactory (const XMLNode&, bool full);
+	boost::shared_ptr<MidiRegion>  XMLMidiRegionFactory (const XMLNode&, bool full);
 
-	template<class T> void foreach_audio_region (T *obj, void (T::*func)(boost::shared_ptr<AudioRegion>));
+	template<class T> void foreach_region (T *obj, void (T::*func)(boost::shared_ptr<Region>));
 
 	/* source management */
 
@@ -567,8 +586,7 @@ class Session : public PBD::StatefulDestructible
 	    std::vector<Glib::ustring> paths;
 	    
 	    /* result */
-	    std::vector<boost::shared_ptr<AudioRegion> > new_regions;
-	    
+	    std::vector<boost::shared_ptr<Region> > new_regions;
 	};
 
 	int import_audiofile (import_status&);
@@ -613,6 +631,8 @@ class Session : public PBD::StatefulDestructible
 	
 	boost::shared_ptr<AudioFileSource> create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
 
+	boost::shared_ptr<MidiSource> create_midi_source_for_session (ARDOUR::MidiDiskstream&);
+
 	boost::shared_ptr<Source> source_by_id (const PBD::ID&);
 	boost::shared_ptr<Source> source_by_path_and_channel (const Glib::ustring&, uint16_t);
 
@@ -660,7 +680,7 @@ class Session : public PBD::StatefulDestructible
 
 	/* flattening stuff */
 
-	int write_one_audio_track (AudioTrack&, nframes_t start, nframes_t cnt, bool overwrite, vector<boost::shared_ptr<AudioSource> >&,
+	int write_one_audio_track (AudioTrack&, nframes_t start, nframes_t cnt, bool overwrite, vector<boost::shared_ptr<Source> >&,
 				   InterThreadInfo& wot);
 	int freeze (InterThreadInfo&);
 
@@ -894,7 +914,7 @@ class Session : public PBD::StatefulDestructible
 	/* buffers for gain and pan */
 
 	gain_t* gain_automation_buffer () const { return _gain_automation_buffer; }
-	pan_t** pan_automation_buffer() const { return _pan_automation_buffer; }
+	pan_t** pan_automation_buffer () const  { return _pan_automation_buffer; }
 
 	/* buffers for conversion */
 	enum RunContext {
@@ -912,18 +932,6 @@ class Session : public PBD::StatefulDestructible
 				  void* ptr,
 				  float opt);
 
-	typedef float (*compute_peak_t)			(Sample *, nframes_t, float);
-	typedef void  (*find_peaks_t)                   (Sample *, nframes_t, float *, float*);
-	typedef void  (*apply_gain_to_buffer_t)		(Sample *, nframes_t, float);
-	typedef void  (*mix_buffers_with_gain_t)	(Sample *, Sample *, nframes_t, float);
-	typedef void  (*mix_buffers_no_gain_t)		(Sample *, Sample *, nframes_t);
-
-	static compute_peak_t		compute_peak;
-	static find_peaks_t             find_peaks;
-	static apply_gain_to_buffer_t	apply_gain_to_buffer;
-	static mix_buffers_with_gain_t	mix_buffers_with_gain;
-	static mix_buffers_no_gain_t	mix_buffers_no_gain;
-
 	static sigc::signal<void> SendFeedback;
 
 	/* Controllables */
@@ -993,9 +1001,9 @@ class Session : public PBD::StatefulDestructible
 	nframes_t          _last_slave_transport_frame;
 	nframes_t           maximum_output_latency;
 	nframes_t           last_stop_frame;
-	vector<Sample *>        _passthru_buffers;
-	vector<Sample *>        _silent_buffers;
-	vector<Sample *>        _send_buffers;
+	BufferSet*              _scratch_buffers;
+	BufferSet*              _silent_buffers;
+	BufferSet*              _send_buffers;
 	nframes_t           current_block_size;
 	nframes_t          _worst_output_latency;
 	nframes_t          _worst_input_latency;
@@ -1012,7 +1020,7 @@ class Session : public PBD::StatefulDestructible
 
 	void update_latency_compensation_proxy (void* ignored);
 
-	void ensure_passthru_buffers (uint32_t howmany);
+	void ensure_buffers (ChanCount howmany);
 	
 	void process_scrub          (nframes_t);
 	void process_without_events (nframes_t);
@@ -1233,7 +1241,7 @@ class Session : public PBD::StatefulDestructible
 	void remove_empty_sounds ();
 
 	void setup_midi_control ();
-	int  midi_read (MIDI::Port *);
+	//int  midi_read (MIDI::Port *);
 
 	void enable_record ();
 	
@@ -1259,13 +1267,13 @@ class Session : public PBD::StatefulDestructible
 	void *do_work();
 
 	void set_next_event ();
-	void process_event (Event *);
+	void process_event (Event *ev);
 
 	/* MIDI Machine Control */
 
 	void deliver_mmc (MIDI::MachineControl::Command, nframes_t);
-	void deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
-	void deliver_data (MIDI::Port* port, MIDI::byte*, int32_t size);
+	//void deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
+	//void deliver_data (MIDI::Port* port, MIDI::byte*, int32_t size);
 
 	void spp_start (MIDI::Parser&);
 	void spp_continue (MIDI::Parser&);
@@ -1308,22 +1316,16 @@ class Session : public PBD::StatefulDestructible
 	nframes_t _smpte_offset;
 	bool _smpte_offset_negative;
 
-	/* cache the most-recently requested time conversions.
-	   this helps when we have multiple clocks showing the
-	   same time (e.g. the transport frame)
-	*/
-
-	bool       last_smpte_valid;
-	nframes_t  last_smpte_when;
-	SMPTE::Time last_smpte;
-
-	int send_full_time_code ();
-	int send_midi_time_code ();
+	/* cache the most-recently requested time conversions. This helps when we
+	 * have multiple clocks showing the same time (e.g. the transport frame) */
+	bool           last_smpte_valid;
+	nframes_t last_smpte_when;
+	SMPTE::Time    last_smpte;
+	
+	bool _send_smpte_update; ///< Flag to send a full frame (SMPTE) MTC message this cycle
 
-	void send_full_time_code_in_another_thread ();
-	void send_midi_time_code_in_another_thread ();
-	void send_time_code_in_another_thread (bool full);
-	void send_mmc_in_another_thread (MIDI::MachineControl::Command, nframes_t frame = 0);
+	int send_full_time_code(nframes_t nframes);
+	int send_midi_time_code_for_cycle(nframes_t nframes);
 
 	nframes_t adjust_apparent_position (nframes_t frames);
 	
@@ -1378,17 +1380,8 @@ class Session : public PBD::StatefulDestructible
 	    static MultiAllocSingleReleasePool pool;
 	};
 
-	Glib::Mutex       midi_lock;
-	pthread_t       midi_thread;
-	int             midi_request_pipe[2];
 	mutable  gint   butler_active;
-	RingBuffer<MIDIRequest*> midi_requests;
-
-	int           start_midi_thread ();
-	void          terminate_midi_thread ();
-	void          poke_midi_thread ();
-	static void *_midi_thread_work (void *arg);
-	void          midi_thread_work ();
+	
 	void          change_midi_ports ();
 	int           use_config_midi_ports ();
 
@@ -1460,8 +1453,8 @@ class Session : public PBD::StatefulDestructible
 	/* REGION MANAGEMENT */
 
 	mutable Glib::Mutex region_lock;
-	typedef map<PBD::ID,boost::shared_ptr<AudioRegion> > AudioRegionList;
-	AudioRegionList audio_regions;
+	typedef map<PBD::ID,boost::shared_ptr<Region> > RegionList;
+	RegionList regions;
 	
 	void add_region (boost::shared_ptr<Region>);
 	void region_changed (Change, boost::weak_ptr<Region>);
@@ -1471,10 +1464,10 @@ class Session : public PBD::StatefulDestructible
 
 	/* SOURCES */
 	
-	mutable Glib::Mutex audio_source_lock;
-	typedef std::map<PBD::ID,boost::shared_ptr<AudioSource> > AudioSourceList;
+	mutable Glib::Mutex source_lock;
+	typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
 
-	AudioSourceList audio_sources;
+	SourceMap sources;
 
 	int load_sources (const XMLNode& node);
 	XMLNode& get_sources_as_xml ();
@@ -1510,9 +1503,9 @@ class Session : public PBD::StatefulDestructible
 	NamedSelection *named_selection_factory (string name);
 	NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
 
-        /* CURVES and AUTOMATION LISTS */
-        std::map<PBD::ID, Curve*> curves;
-        std::map<PBD::ID, AutomationList*> automation_lists;
+	/* CURVES and AUTOMATION LISTS */
+	std::map<PBD::ID, Curve*> curves;
+	std::map<PBD::ID, AutomationList*> automation_lists;
 
 	/* DEFAULT FADE CURVES */
 
@@ -1689,7 +1682,7 @@ class Session : public PBD::StatefulDestructible
 			    void* ptr,
 			    float opt);
 
-	/* number of hardware audio ports we're using,
+	/* number of hardware ports we're using,
 	   based on max (requested,available)
 	*/
 
diff --git a/libs/ardour/ardour/session_region.h b/libs/ardour/ardour/session_region.h
index 66868f6d18..254bbfe1a3 100644
--- a/libs/ardour/ardour/session_region.h
+++ b/libs/ardour/ardour/session_region.h
@@ -25,14 +25,14 @@
 
 namespace ARDOUR {
 
-template<class T> void Session::foreach_audio_region (T *obj, void (T::*func)(boost::shared_ptr<AudioRegion>))
+template<class T> void Session::foreach_region (T *obj, void (T::*func)(boost::shared_ptr<Region>))
 {
 	Glib::Mutex::Lock lm (region_lock);
-	for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); i++) {
+	for (RegionList::iterator i = regions.begin(); i != regions.end(); i++) {
 		(obj->*func) (i->second);
 	}
 }
 
-}
+} // namespace ARDOUR
 
 #endif /* __ardour_session_region_h__ */
diff --git a/libs/ardour/ardour/smf_source.h b/libs/ardour/ardour/smf_source.h
new file mode 100644
index 0000000000..d422a8af9e
--- /dev/null
+++ b/libs/ardour/ardour/smf_source.h
@@ -0,0 +1,125 @@
+/*
+    Copyright (C) 2006 Paul Davis
+	Written by Dave Robillard, 2006
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#ifndef __ardour_smf_filesource_h__ 
+#define __ardour_smf_filesource_h__
+
+#include <cstdio>
+#include <time.h>
+
+#include <ardour/midi_source.h>
+
+namespace ARDOUR {
+
+class MidiRingBuffer;
+
+/** Standard Midi File (Type 0) Source */
+class SMFSource : public MidiSource {
+  public:
+	enum Flag {
+		Writable = 0x1,
+		CanRename = 0x2,
+		Broadcast = 0x4,
+		Removable = 0x8,
+		RemovableIfEmpty = 0x10,
+		RemoveAtDestroy = 0x20,
+		BuildPeaks = 0x40
+	};
+	
+	/** Constructor for existing external-to-session files */
+	SMFSource (Session& session, std::string path, Flag flags = Flag(0));
+
+	/* Constructor for existing in-session files */
+	SMFSource (Session& session, const XMLNode&);
+
+	virtual ~SMFSource ();
+
+	/* this block of methods do nothing for regular file sources, but are significant
+	   for files used in destructive recording.
+	*/
+	// FIXME and thus are useless for MIDI.. but make MidiDiskstream compile easier! :)
+
+	virtual nframes_t last_capture_start_frame() const { return 0; }
+	virtual void           mark_capture_start (nframes_t) {}
+	virtual void           mark_capture_end () {}
+	virtual void           clear_capture_marks() {}
+
+	int set_name (string newname, bool destructive);
+
+	string path() const { return _path; }
+
+	void set_allow_remove_if_empty (bool yn);
+	void mark_for_remove();
+
+	int update_header (nframes_t when, struct tm&, time_t);
+	int flush_header ();
+	int flush_footer ();
+
+	int move_to_trash (const string trash_dir_name);
+
+	static bool is_empty (string path);
+	void mark_streaming_write_completed ();
+
+	void   mark_take (string);
+	string take_id() const { return _take_id; }
+
+	static void set_search_path (string);
+	static void set_header_position_offset (nframes_t offset, bool negative);
+
+	XMLNode& get_state ();
+	int set_state (const XMLNode&);
+
+  private:
+
+	int init (string idstr, bool must_exist);
+
+	nframes_t read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cn, nframes_t stamp_offset) const;
+	nframes_t write_unlocked (MidiRingBuffer& dst, nframes_t cnt);
+
+	bool find (std::string path, bool must_exist, bool& is_new);
+	bool removable() const;
+	bool writable() const { return _flags & Writable; }
+	
+	int open();
+	
+	void     write_chunk_header(char id[4], uint32_t length);
+	void     write_chunk(char id[4], uint32_t length, void* data);
+	size_t   write_var_len(uint32_t val);
+	uint32_t read_var_len() const;
+	int      read_event(MidiEvent& ev) const;
+
+	uint16_t       _channel;
+	string         _path;
+	Flag           _flags;
+	string         _take_id;
+	bool           _allow_remove_if_empty;
+	uint64_t       _timeline_position;
+	FILE*          _fd;
+	nframes_t _last_ev_time; // last frame time written, relative to source start
+	uint32_t       _track_size;
+	uint32_t       _header_size; // size of SMF header, including MTrk chunk header
+
+	static string _search_path;
+};
+
+}; /* namespace ARDOUR */
+
+#endif /* __ardour_smf_filesource_h__ */
+
diff --git a/libs/ardour/ardour/smpte.h b/libs/ardour/ardour/smpte.h
new file mode 100644
index 0000000000..d0901c372e
--- /dev/null
+++ b/libs/ardour/ardour/smpte.h
@@ -0,0 +1,79 @@
+/*  Copyright (C) 2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    This program 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 General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef __ardour_smpte_h__
+#define __ardour_smpte_h__
+
+#include <inttypes.h>
+
+namespace SMPTE {
+
+enum Wrap {
+	NONE = 0,
+	FRAMES,
+	SECONDS,
+	MINUTES,
+	HOURS
+};
+
+/** SMPTE frame rate (in frames per second).
+ *
+ * This should be eliminated in favour of a float to support arbitrary rates.
+ */
+enum FPS {
+    MTC_24_FPS = 0,
+    MTC_25_FPS = 1,
+    MTC_30_FPS_DROP = 2,
+    MTC_30_FPS = 3
+};
+
+struct Time {
+	bool       negative;
+	uint32_t   hours;
+	uint32_t   minutes;
+	uint32_t   seconds;
+	uint32_t   frames;       ///< SMPTE frames (not audio samples)
+	uint32_t   subframes;    ///< Typically unused
+	FPS        rate;         ///< Frame rate of this Time
+	static FPS default_rate; ///< Rate to use for default constructor
+
+	Time(FPS a_rate = default_rate) {
+		negative = false;
+		hours = 0;
+		minutes = 0;
+		seconds = 0;
+		frames = 0;
+		subframes = 0;
+		rate = a_rate;
+	}
+};
+
+Wrap increment( Time& smpte );
+Wrap decrement( Time& smpte );
+Wrap increment_subframes( Time& smpte );
+Wrap decrement_subframes( Time& smpte );
+Wrap increment_seconds( Time& smpte );
+Wrap increment_minutes( Time& smpte );
+Wrap increment_hours( Time& smpte );
+void frames_floor( Time& smpte );
+void seconds_floor( Time& smpte );
+void minutes_floor( Time& smpte );
+void hours_floor( Time& smpte );
+
+} // namespace SMPTE
+
+#endif  // __ardour_smpte_h__
diff --git a/libs/ardour/ardour/source.h b/libs/ardour/ardour/source.h
index 7ffa616a40..807ea089e6 100644
--- a/libs/ardour/ardour/source.h
+++ b/libs/ardour/ardour/source.h
@@ -28,6 +28,7 @@
 #include <pbd/statefuldestructible.h> 
 
 #include <ardour/ardour.h>
+#include <ardour/data_type.h>
 
 namespace ARDOUR {
 
@@ -37,31 +38,49 @@ class Playlist;
 class Source : public PBD::StatefulDestructible
 {
   public:
-	Source (Session&, std::string name);
+	Source (Session&, std::string name, DataType type);
 	Source (Session&, const XMLNode&);
+	
 	virtual ~Source ();
 
 	std::string name() const { return _name; }
 	int set_name (std::string str, bool destructive);
 
+	DataType type() { return _type; }
+
 	time_t timestamp() const { return _timestamp; }
 	void stamp (time_t when) { _timestamp = when; }
+	
+	/** @return the number of items in this source */
+	nframes_t length() const { return _length; }
+
+	virtual nframes_t natural_position() const { return 0; }
 
+	virtual void mark_for_remove() = 0;
+	virtual void mark_streaming_write_completed () = 0;
+	
 	XMLNode& get_state ();
 	int set_state (const XMLNode&);
-
+	
 	void use () { _in_use++; }
 	void disuse () { if (_in_use) { _in_use--; } }
-
+	
 	void add_playlist (boost::shared_ptr<ARDOUR::Playlist>);
 	void remove_playlist (boost::weak_ptr<ARDOUR::Playlist>);
 
 	uint32_t used() const;
 
+	
+	static sigc::signal<void,Source*> SourceCreated;
+
   protected:
+	void update_length (nframes_t pos, nframes_t cnt);
+	
 	Session&          _session;
 	string            _name;
+	DataType          _type;
 	time_t            _timestamp;
+	nframes_t    _length;
 
 	Glib::Mutex playlist_lock;
 	typedef std::map<boost::shared_ptr<ARDOUR::Playlist>, uint32_t > PlaylistMap;
diff --git a/libs/ardour/ardour/source_factory.h b/libs/ardour/ardour/source_factory.h
index c979a575cf..fb591216bf 100644
--- a/libs/ardour/ardour/source_factory.h
+++ b/libs/ardour/ardour/source_factory.h
@@ -41,9 +41,8 @@ class SourceFactory {
 	static boost::shared_ptr<Source> create (Session&, const XMLNode& node);
 	static boost::shared_ptr<Source> createSilent (Session&, const XMLNode& node, nframes_t nframes, float sample_rate);
 
-	// MIDI sources will have to be hacked in here somehow
-	static boost::shared_ptr<Source> createReadable (Session&, std::string path, int chn, AudioFileSource::Flag flags, bool announce = true);
-	static boost::shared_ptr<Source> createWritable (Session&, std::string name, bool destructive, nframes_t rate, bool announce = true);
+	static boost::shared_ptr<Source> createReadable (DataType type, Session&, std::string path, int chn, AudioFileSource::Flag flags, bool announce = true);
+	static boost::shared_ptr<Source> createWritable (DataType type, Session&, std::string name, bool destructive, nframes_t rate, bool announce = true);
 
   private:
 	static int setup_peakfile (boost::shared_ptr<Source>);
diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index 9c99ecfd25..eee04d9bfa 100644
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -55,7 +55,7 @@ class Track : public Route
 
 	void toggle_monitor_input ();
 
-	virtual bool can_record();
+	bool can_record();
 
 	boost::shared_ptr<Diskstream> diskstream() const { return _diskstream; }
 
@@ -98,11 +98,6 @@ class Track : public Route
 
 	virtual XMLNode& state (bool full) = 0;
 
-	virtual void passthru_silence (nframes_t start_frame, nframes_t end_frame, 
-		nframes_t nframes, nframes_t offset, int declick, bool meter) = 0;
-
-	virtual uint32_t n_process_buffers () = 0;
-	
 	boost::shared_ptr<Diskstream> _diskstream;
 	MeterPoint  _saved_meter_point;
 	TrackMode   _mode;
diff --git a/libs/ardour/ardour/types.h b/libs/ardour/ardour/types.h
index 05956336b6..b155965cab 100644
--- a/libs/ardour/ardour/types.h
+++ b/libs/ardour/ardour/types.h
@@ -30,6 +30,7 @@
 
 #include <inttypes.h>
 #include <jack/types.h>
+#include <jack/midiport.h>
 #include <control_protocol/smpte.h>
 #include <pbd/id.h>
 
@@ -40,13 +41,6 @@
 typedef int intptr_t;
 #endif
 
-/* at some point move this into the ARDOUR namespace,
-   but for now its outside because it replaces the
-   old global "jack_nframes_t"
-*/
-
-typedef uint32_t                    nframes_t;
-
 namespace ARDOUR {
 
 	class Source;
@@ -57,6 +51,10 @@ namespace ARDOUR {
 	typedef float                       gain_t;
 	typedef uint32_t                    layer_t;
 	typedef uint64_t                    microseconds_t;
+	typedef uint32_t                    nframes_t;
+
+	typedef jack_midi_event_t MidiEvent;
+	typedef unsigned char     RawMidi;
 
 	enum IOChange {
 		NoChange = 0,
@@ -345,8 +343,7 @@ namespace ARDOUR {
 		Semitones
 	};
 
-	typedef std::vector<boost::shared_ptr<AudioSource> > SourceList;
-
+	typedef std::vector<boost::shared_ptr<Source> > SourceList;
 } // namespace ARDOUR
 
 std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
@@ -363,6 +360,8 @@ std::istream& operator>>(std::istream& o, ARDOUR::ShuttleBehaviour& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::ShuttleUnits& sf);
 std::istream& operator>>(std::istream& o, ARDOUR::SmpteFormat& sf);
 
+using ARDOUR::nframes_t;
+
 static inline nframes_t
 session_frame_to_track_frame (nframes_t session_frame, double speed)
 {
diff --git a/libs/ardour/ardour/vst_plugin.h b/libs/ardour/ardour/vst_plugin.h
index fb03a75bb8..f7ec486d36 100644
--- a/libs/ardour/ardour/vst_plugin.h
+++ b/libs/ardour/ardour/vst_plugin.h
@@ -72,6 +72,8 @@ class VSTPlugin : public ARDOUR::Plugin
 	void deactivate ();
 	void set_block_size (nframes_t nframes);
 	int connect_and_run (vector<Sample*>& bufs, uint32_t maxbuf, int32_t& in, int32_t& out, nframes_t nframes, nframes_t offset);
+	void store_state (ARDOUR::PluginState&);
+	void restore_state (ARDOUR::PluginState&);
 	string describe_parameter (uint32_t);
 	string state_node_name() const { return "vst"; }
 	void print_parameter (uint32_t, char*, uint32_t len) const;
diff --git a/libs/ardour/audio_diskstream.cc b/libs/ardour/audio_diskstream.cc
index b372c14b57..3b66d2a187 100644
--- a/libs/ardour/audio_diskstream.cc
+++ b/libs/ardour/audio_diskstream.cc
@@ -50,6 +50,7 @@
 #include <ardour/playlist_factory.h>
 #include <ardour/cycle_timer.h>
 #include <ardour/audioregion.h>
+#include <ardour/audio_port.h>
 #include <ardour/source_factory.h>
 
 #include "i18n.h"
@@ -112,7 +113,7 @@ AudioDiskstream::init (Diskstream::Flag f)
 	allocate_temporary_buffers ();
 
 	add_channel (1);
-	assert(_n_channels == 1);
+	assert(_n_channels == ChanCount(DataType::AUDIO, 1));
 }
 
 AudioDiskstream::~AudioDiskstream ()
@@ -167,12 +168,12 @@ AudioDiskstream::non_realtime_input_change ()
 			RCUWriter<ChannelList> writer (channels);
 			boost::shared_ptr<ChannelList> c = writer.get_copy();
 			
-			_n_channels = c->size();
+			_n_channels.set(DataType::AUDIO, c->size());
 			
-			if (_io->n_inputs() > _n_channels) {
-				add_channel_to (c, _io->n_inputs() - _n_channels);
-			} else if (_io->n_inputs() < _n_channels) {
-				remove_channel_from (c, _n_channels - _io->n_inputs());
+			if (_io->n_inputs().get(DataType::AUDIO) > _n_channels.get(DataType::AUDIO)) {
+				add_channel_to (c, _io->n_inputs().get(DataType::AUDIO) - _n_channels.get(DataType::AUDIO));
+			} else if (_io->n_inputs().get(DataType::AUDIO) < _n_channels.get(DataType::AUDIO)) {
+				remove_channel_from (c, _n_channels.get(DataType::AUDIO) - _io->n_inputs().get(DataType::AUDIO));
 			}
 		}
 		
@@ -211,7 +212,7 @@ AudioDiskstream::get_input_sources ()
 
 	uint32_t n;
 	ChannelList::iterator chan;
-	uint32_t ni = _io->n_inputs();
+	uint32_t ni = _io->n_inputs().get(DataType::AUDIO);
 
 	for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
 		
@@ -226,7 +227,8 @@ AudioDiskstream::get_input_sources ()
 			(*chan)->source = 0;
 			
 		} else {
-			(*chan)->source = _session.engine().get_port_by_name (connections[0]);
+			(*chan)->source = dynamic_cast<AudioPort*>(
+				_session.engine().get_port_by_name (connections[0]) );
 		}
 		
 		if (connections) {
@@ -241,7 +243,7 @@ AudioDiskstream::find_and_use_playlist (const string& name)
 	boost::shared_ptr<AudioPlaylist> playlist;
 		
 	if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
-		playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (_session, name));
+		playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
 	}
 
 	if (!playlist) {
@@ -278,7 +280,7 @@ AudioDiskstream::use_new_playlist ()
 		newname = Playlist::bump_name (_name, _session);
 	}
 
-	if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (_session, newname, hidden()))) != 0) {
+	if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
 		
 		playlist->set_orig_diskstream_id (id());
 		return use_playlist (playlist);
@@ -610,7 +612,7 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_
 
 	if (nominally_recording || rec_nframes) {
 
-		uint32_t limit = _io->n_inputs ();
+		uint32_t limit = _io->n_inputs ().get(DataType::AUDIO);
 
 		/* one or more ports could already have been removed from _io, but our
 		   channel setup hasn't yet been updated. prevent us from trying to
@@ -633,7 +635,10 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_
 				   rec_offset
 				*/
 
-				memcpy (chaninfo->current_capture_buffer, _io->input(n)->get_buffer (rec_nframes) + offset + rec_offset, sizeof (Sample) * rec_nframes);
+				AudioPort* const ap = _io->audio_input(n);
+				assert(ap);
+				assert(rec_nframes <= ap->get_audio_buffer().capacity());
+				memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer().data(rec_nframes, offset + rec_offset), sizeof (Sample) * rec_nframes);
 
 			} else {
 
@@ -644,7 +649,10 @@ AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_
 					goto out;
 				}
 
-				Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
+				AudioPort* const ap = _io->audio_input(n);
+				assert(ap);
+
+				Sample* buf = ap->get_audio_buffer().data(nframes, offset);
 				nframes_t first = chaninfo->capture_vector.len[0];
 
 				memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
@@ -932,7 +940,7 @@ int
 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
 {
 	uint32_t n;
-	int ret;
+	int ret = -1;
 	ChannelList::iterator chan;
 	boost::shared_ptr<ChannelList> c = channels.reader();
 
@@ -1612,7 +1620,7 @@ AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_ca
 		}
 
 		_playlist->thaw ();
-                XMLNode &after = _playlist->get_state();
+		XMLNode &after = _playlist->get_state();
 		_session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
 	}
 
@@ -1683,7 +1691,7 @@ AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<Chan
 void
 AudioDiskstream::set_record_enabled (bool yn)
 {
-	if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs() == 0) {
+	if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs().get(DataType::AUDIO) == 0) {
 		return;
 	}
 
@@ -1863,15 +1871,15 @@ AudioDiskstream::set_state (const XMLNode& node)
 	// create necessary extra channels
 	// we are always constructed with one and we always need one
 
-	_n_channels = channels.reader()->size();
+	_n_channels.set(DataType::AUDIO, channels.reader()->size());
 	
-	if (nchans > _n_channels) {
+	if (nchans > _n_channels.get(DataType::AUDIO)) {
 
-		add_channel (nchans - _n_channels);
+		add_channel (nchans - _n_channels.get(DataType::AUDIO));
 
-	} else if (nchans < _n_channels) {
+	} else if (nchans < _n_channels.get(DataType::AUDIO)) {
 
-		remove_channel (_n_channels - nchans);
+		remove_channel (_n_channels.get(DataType::AUDIO) - nchans);
 	}
 
 	if ((prop = node.property ("playlist")) == 0) {
@@ -2112,7 +2120,7 @@ AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_
 		c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
 	}
 
-	_n_channels = c->size();
+	_n_channels.set(DataType::AUDIO, c->size());
 
 	return 0;
 }
@@ -2134,7 +2142,7 @@ AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t
 		c->pop_back();
 	}
 
-	_n_channels = c->size();
+	_n_channels.set(DataType::AUDIO, c->size());
 
 	return 0;
 }
@@ -2193,7 +2201,8 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 			}
 
 			try {
-				fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (_session, prop->value(), false, _session.frame_rate()));
+				fs = boost::dynamic_pointer_cast<AudioFileSource> (
+					SourceFactory::createWritable (DataType::AUDIO, _session, prop->value(), false, _session.frame_rate()));
 			}
 
 			catch (failed_constructor& err) {
@@ -2218,7 +2227,7 @@ AudioDiskstream::use_pending_capture_data (XMLNode& node)
 		return 1;
 	}
 
-	if (pending_sources.size() != _n_channels) {
+	if (pending_sources.size() != _n_channels.get(DataType::AUDIO)) {
 		error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
 		      << endmsg;
 		return -1;
diff --git a/libs/ardour/audio_playlist.cc b/libs/ardour/audio_playlist.cc
index 1a7405dbd3..929101fe6d 100644
--- a/libs/ardour/audio_playlist.cc
+++ b/libs/ardour/audio_playlist.cc
@@ -40,15 +40,18 @@ using namespace std;
 using namespace PBD;
 
 AudioPlaylist::AudioPlaylist (Session& session, const XMLNode& node, bool hidden)
-	: Playlist (session, node, hidden)
+	: Playlist (session, node, DataType::AUDIO, hidden)
 {
+	const XMLProperty* prop = node.property("type");
+	assert(!prop || DataType(prop->value()) == DataType::AUDIO);
+
 	in_set_state++;
 	set_state (node);
 	in_set_state--;
 }
 
 AudioPlaylist::AudioPlaylist (Session& session, string name, bool hidden)
-	: Playlist (session, name, hidden)
+	: Playlist (session, name, DataType::AUDIO, hidden)
 {
 }
 
@@ -106,17 +109,17 @@ AudioPlaylist::~AudioPlaylist ()
 	/* drop connections to signals */
 
 	notify_callbacks ();
-
+	
 	_crossfades.clear ();
 }
 
 struct RegionSortByLayer {
-    bool operator() (boost::shared_ptr<Region>a, boost::shared_ptr<Region>b) {
+    bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
 	    return a->layer() < b->layer();
     }
 };
 
-nframes_t
+ARDOUR::nframes_t
 AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t start,
 		     nframes_t cnt, unsigned chan_n)
 {
diff --git a/libs/ardour/audio_port.cc b/libs/ardour/audio_port.cc
new file mode 100644
index 0000000000..ae64995000
--- /dev/null
+++ b/libs/ardour/audio_port.cc
@@ -0,0 +1,54 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <cassert>
+#include <ardour/audio_port.h>
+#include <ardour/data_type.h>
+
+using namespace ARDOUR;
+using namespace std;
+
+nframes_t AudioPort::_short_over_length = 2;
+nframes_t AudioPort::_long_over_length = 10;
+
+AudioPort::AudioPort(jack_port_t* p)
+	: Port(p)
+	, _buffer(0)
+{
+	DataType dt(_type);
+	assert(dt == DataType::AUDIO);
+	
+	reset();
+}
+
+void
+AudioPort::reset()
+{
+	Port::reset();
+	if (_flags & JackPortIsOutput) {
+		if (_buffer.capacity() > 0) {
+			_buffer.clear();
+		}
+		assert(_buffer.silent());
+	}
+	
+	_metering = 0;
+	reset_meters ();
+}
+
+
diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc
index 7c25a8c899..7274082e8e 100644
--- a/libs/ardour/audio_track.cc
+++ b/libs/ardour/audio_track.cc
@@ -37,7 +37,7 @@
 #include <ardour/playlist_factory.h>
 #include <ardour/panner.h>
 #include <ardour/utils.h>
-
+#include <ardour/buffer_set.h>
 #include "i18n.h"
 
 using namespace std;
@@ -123,10 +123,10 @@ AudioTrack::deprecated_use_diskstream_connections ()
 
 	diskstream->deprecated_io_node = 0;
 
-	set_input_minimum (-1);
-	set_input_maximum (-1);
-	set_output_minimum (-1);
-	set_output_maximum (-1);
+	set_input_minimum (ChanCount::ZERO);
+	set_input_maximum (ChanCount::INFINITE);
+	set_output_minimum (ChanCount::ZERO);
+	set_output_maximum (ChanCount::INFINITE);
 	
 	if ((prop = node.property ("gain")) != 0) {
 		set_gain (atof (prop->value().c_str()), this);
@@ -423,24 +423,11 @@ AudioTrack::set_state_part_two ()
 	return;
 }	
 
-uint32_t
-AudioTrack::n_process_buffers ()
-{
-	return max ((uint32_t) _diskstream->n_channels(), redirect_max_outs);
-}
-
-void
-AudioTrack::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
-{
-	uint32_t nbufs = n_process_buffers ();
-	process_output_buffers (_session.get_silent_buffers (nbufs), nbufs, start_frame, end_frame, nframes, offset, true, declick, meter);
-}
-
 int 
 AudioTrack::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, 
 		     bool session_state_changing, bool can_record, bool rec_monitors_input)
 {
-	if (n_outputs() == 0) {
+	if (n_outputs().get_total() == 0) {
 		return 0;
 	}
 
@@ -536,7 +523,7 @@ AudioTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
 	}
 
 	
-	if (n_outputs() == 0 && _redirects.empty()) {
+	if (n_outputs().get_total() == 0 && _redirects.empty()) {
 		return 0;
 	}
 
@@ -592,16 +579,15 @@ AudioTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
 		
 		/* copy the diskstream data to all output buffers */
 		
-		vector<Sample*>& bufs = _session.get_passthru_buffers ();
-		uint32_t limit = n_process_buffers ();
+		const size_t limit = n_process_buffers().get(DataType::AUDIO);
+		BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
 		
 		uint32_t n;
 		uint32_t i;
 
-
 		for (i = 0, n = 1; i < limit; ++i, ++n) {
-			memcpy (bufs[i], b, sizeof (Sample) * nframes); 
-			if (n < diskstream->n_channels()) {
+			memcpy (bufs.get_audio(i).data(), b, sizeof (Sample) * nframes); 
+			if (n < diskstream->n_channels().get(DataType::AUDIO)) {
 				tmpb = diskstream->playback_buffer(n);
 				if (tmpb!=0) {
 					b = tmpb;
@@ -619,7 +605,7 @@ AudioTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
 			}
 		}
 
-		process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput));
+		process_output_buffers (bufs, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput));
 		
 	} else {
 		/* problem with the diskstream; just be quiet for a bit */
@@ -633,7 +619,7 @@ int
 AudioTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, 
 			 bool can_record, bool rec_monitors_input)
 {
-	if (n_outputs() == 0 && _redirects.empty()) {
+	if (n_outputs().get_total() == 0 && _redirects.empty()) {
 		return 0;
 	}
 
@@ -651,7 +637,7 @@ AudioTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end
 }
 
 int
-AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t start, nframes_t nframes)
+AudioTrack::export_stuff (BufferSet& buffers, nframes_t start, nframes_t nframes)
 {
 	gain_t  gain_automation[nframes];
 	gain_t  gain_buffer[nframes];
@@ -659,8 +645,6 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t st
 	RedirectList::iterator i;
 	bool post_fader_work = false;
 	gain_t this_gain = _gain;
-	vector<Sample*>::iterator bi;
-	Sample * b;
 	boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
 	
 	Glib::RWLock::ReaderLock rlock (redirect_lock);
@@ -668,24 +652,26 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t st
 	boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist());
 	assert(apl);
 
-	if (apl->read (buffers[0], mix_buffer, gain_buffer, start, nframes) != nframes) {
+	if (apl->read (buffers.get_audio(nframes).data(),
+			mix_buffer, gain_buffer, start, nframes) != nframes) {
 		return -1;
 	}
 
+	assert(buffers.count().get(DataType::AUDIO) >= 1);
 	uint32_t n=1;
-	bi = buffers.begin();
-	b = buffers[0];
+	Sample* b = buffers.get_audio(0).data();
+	BufferSet::audio_iterator bi = buffers.audio_begin();
 	++bi;
-	for (; bi != buffers.end(); ++bi, ++n) {
-		if (n < diskstream->n_channels()) {
-			if (apl->read ((*bi), mix_buffer, gain_buffer, start, nframes, n) != nframes) {
+	for ( ; bi != buffers.audio_end(); ++bi, ++n) {
+		if (n < diskstream->n_channels().get(DataType::AUDIO)) {
+			if (apl->read (bi->data(), mix_buffer, gain_buffer, start, nframes, n) != nframes) {
 				return -1;
 			}
-			b = (*bi);
+			b = bi->data();
 		}
 		else {
 			/* duplicate last across remaining buffers */
-			memcpy ((*bi), b, sizeof (Sample) * nframes); 
+			memcpy (bi->data(), b, sizeof (Sample) * nframes); 
 		}
 	}
 
@@ -700,7 +686,7 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t st
 		if ((insert = boost::dynamic_pointer_cast<Insert>(*i)) != 0) {
 			switch (insert->placement()) {
 			case PreFader:
-				insert->run (buffers, nbufs, nframes, 0);
+				insert->run (buffers, start, start+nframes, nframes, 0);
 				break;
 			case PostFader:
 				post_fader_work = true;
@@ -713,8 +699,8 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t st
 		
 		_gain_automation_curve.get_vector (start, start + nframes, gain_automation, nframes);
 
-		for (bi = buffers.begin(); bi != buffers.end(); ++bi) {
-			Sample *b = *bi;
+		for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) {
+			Sample *b = bi->data();
 			for (nframes_t n = 0; n < nframes; ++n) {
 				b[n] *= gain_automation[n];
 			}
@@ -722,8 +708,8 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t st
 
 	} else {
 
-		for (bi = buffers.begin(); bi != buffers.end(); ++bi) {
-			Sample *b = *bi;
+		for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) {
+			Sample *b = bi->data();
 			for (nframes_t n = 0; n < nframes; ++n) {
 				b[n] *= this_gain;
 			}
@@ -740,7 +726,7 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t st
 				case PreFader:
 					break;
 				case PostFader:
-					insert->run (buffers, nbufs, nframes, 0);
+					insert->run (buffers, start, start+nframes, nframes, 0);
 					break;
 				}
 			}
@@ -753,7 +739,7 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, nframes_t st
 void
 AudioTrack::bounce (InterThreadInfo& itt)
 {
-	vector<boost::shared_ptr<AudioSource> > srcs;
+	vector<boost::shared_ptr<Source> > srcs;
 	_session.write_one_audio_track (*this, 0, _session.current_end_frame(), false, srcs, itt);
 }
 
@@ -761,14 +747,14 @@ AudioTrack::bounce (InterThreadInfo& itt)
 void
 AudioTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt)
 {
-	vector<boost::shared_ptr<AudioSource> > srcs;
+	vector<boost::shared_ptr<Source> > srcs;
 	_session.write_one_audio_track (*this, start, end, false, srcs, itt);
 }
 
 void
 AudioTrack::freeze (InterThreadInfo& itt)
 {
-	vector<boost::shared_ptr<AudioSource> > srcs;
+	vector<boost::shared_ptr<Source> > srcs;
 	string new_playlist_name;
 	boost::shared_ptr<Playlist> new_playlist;
 	string dir;
@@ -832,14 +818,14 @@ AudioTrack::freeze (InterThreadInfo& itt)
 		}
 	}
 
-	new_playlist = PlaylistFactory::create (_session, new_playlist_name, false);
+	new_playlist = PlaylistFactory::create (DataType::AUDIO, _session, new_playlist_name, false);
 	region_name = new_playlist_name;
 
 	/* create a new region from all filesources, keep it private */
 
 	boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, srcs[0]->length(), 
 								 region_name, 0, 
-								 (AudioRegion::Flag) (AudioRegion::WholeFile|AudioRegion::DefaultFlags),
+								 (Region::Flag) (Region::WholeFile|Region::DefaultFlags),
 								 false));
 
 	new_playlist->set_orig_diskstream_id (diskstream->id());
diff --git a/libs/ardour/audio_unit.cc b/libs/ardour/audio_unit.cc
index 6879123ff1..ac240828b5 100644
--- a/libs/ardour/audio_unit.cc
+++ b/libs/ardour/audio_unit.cc
@@ -190,6 +190,18 @@ AUPlugin::automatable() const
 	return automates;
 }
 
+void
+AUPlugin::store_state (ARDOUR::PluginState&)
+{
+	
+}
+
+void
+AUPlugin::restore_state (ARDOUR::PluginState&)
+{
+	
+}
+
 string
 AUPlugin::describe_parameter (uint32_t)
 {
diff --git a/libs/ardour/audioengine.cc b/libs/ardour/audioengine.cc
index 3654e647a3..3b85ea2147 100644
--- a/libs/ardour/audioengine.cc
+++ b/libs/ardour/audioengine.cc
@@ -20,14 +20,19 @@
 #include <unistd.h>
 #include <cerrno>
 #include <vector>
+#include <exception>
+#include <stdexcept>
 
 #include <glibmm/timer.h>
 #include <pbd/pthread_utils.h>
 #include <pbd/stacktrace.h>
+#include <pbd/unknown_type.h>
 
 #include <ardour/audioengine.h>
 #include <ardour/buffer.h>
 #include <ardour/port.h>
+#include <ardour/audio_port.h>
+#include <ardour/midi_port.h>
 #include <ardour/session.h>
 #include <ardour/cycle_timer.h>
 #include <ardour/utils.h>
@@ -299,16 +304,26 @@ AudioEngine::process_callback (nframes_t nframes)
 		return 0;
 	}
 
-	session->process (nframes);
+	boost::shared_ptr<Ports> p = ports.reader();
+
+	// Prepare ports (ie read data if necessary)
+	for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
+		(*i)->cycle_start (nframes);
+	}
+	
+	if (session) {
+		session->process (nframes);
+	}
 
 	if (!_running) {
-		/* we were zombified, maybe because a ladspa plugin took
-		   too long, or jackd exited, or something like that.
-		*/
-		
 		_processed_frames = next_processed_frames;
 		return 0;
 	}
+	
+	// Finalize ports (ie write data if necessary)
+	for (Ports::iterator i = p->begin(); i != p->end(); ++i) {
+		(*i)->cycle_end ();
+	}
 
 	if (last_monitor_check + monitor_check_interval < next_processed_frames) {
 
@@ -432,14 +447,23 @@ AudioEngine::set_session (Session *s)
 		   can before we really start running.
 		*/
 		
-		session->process (blocksize);
-		session->process (blocksize);
-		session->process (blocksize);
-		session->process (blocksize);
-		session->process (blocksize);
-		session->process (blocksize);
-		session->process (blocksize);
-		session->process (blocksize);
+		boost::shared_ptr<Ports> p = ports.reader();
+
+		for (Ports::iterator i = p->begin(); i != p->end(); ++i)
+			(*i)->cycle_start (blocksize);
+
+		s->process (blocksize);
+		s->process (blocksize);
+		s->process (blocksize);
+		s->process (blocksize);
+		s->process (blocksize);
+		s->process (blocksize);
+		s->process (blocksize);
+		s->process (blocksize);
+
+		for (Ports::iterator i = p->begin(); i != p->end(); ++i)
+			(*i)->cycle_end ();
+
 	}
 }
 
@@ -478,9 +502,16 @@ AudioEngine::register_input_port (DataType type, const string& portname)
 
 	if (p) {
 
-		Port *newport;
-
-		if ((newport = new Port (p)) != 0) {
+		Port* newport = 0;
+		
+		if (type == DataType::AUDIO)
+			newport = new AudioPort (p);
+		else if (type == DataType::MIDI)
+			newport = new MidiPort (p);
+		else
+			throw unknown_type();
+
+		if (newport != 0) {
 			RCUWriter<Ports> writer (ports);
 			boost::shared_ptr<Ports> ps = writer.get_copy ();
 			ps->insert (ps->begin(), newport);
@@ -508,25 +539,29 @@ AudioEngine::register_output_port (DataType type, const string& portname)
 		}
 	}
 
-	jack_port_t *p;
-
+	jack_port_t* p = 0;
+	
 	if ((p = jack_port_register (_jack, portname.c_str(),
-		type.to_jack_type(), JackPortIsOutput, 0)) != 0) {
-
-		Port *newport = 0;
-
-		{
+			type.to_jack_type(), JackPortIsOutput, 0)) != 0) {
+		
+		Port* newport = 0;
+		
+		if (type == DataType::AUDIO)
+			newport = new AudioPort (p);
+		else if (type == DataType::MIDI)
+			newport = new MidiPort (p);
+		else
+			throw unknown_type ();
+
+		if (newport != 0) {
 			RCUWriter<Ports> writer (ports);
 			boost::shared_ptr<Ports> ps = writer.get_copy ();
-			
-			newport = new Port (p);
 			ps->insert (ps->begin(), newport);
-
 			/* writer goes out of scope, forces update */
 		}
-
+		
 		return newport;
-
+		
 	} else {
 		throw PortRegistrationFailure ();
 	}
@@ -536,44 +571,38 @@ AudioEngine::register_output_port (DataType type, const string& portname)
 
 
 int          
-AudioEngine::unregister_port (Port *port)
+AudioEngine::unregister_port (Port& port)
 {
 	if (!_running) { 
 		/* probably happening when the engine has been halted by JACK,
 		   in which case, there is nothing we can do here.
-		*/
+		   */
 		return 0;
 	}
 
-	if (port) {
+	int ret = jack_port_unregister (_jack, port._port);
 
-		int ret = jack_port_unregister (_jack, port->_port);
-		
-		if (ret == 0) {
-			
-			{
-
-				RCUWriter<Ports> writer (ports);
-				boost::shared_ptr<Ports> ps = writer.get_copy ();
-				
-				for (Ports::iterator i = ps->begin(); i != ps->end(); ++i) {
-					if ((*i) == port) {
-						ps->erase (i);
-						break;
-					}
-				}
+	if (ret == 0) {
+
+		{
+
+			RCUWriter<Ports> writer (ports);
+			boost::shared_ptr<Ports> ps = writer.get_copy ();
 
-				/* writer goes out of scope, forces update */
+			for (Ports::iterator i = ps->begin(); i != ps->end(); ++i) {
+				if ((*i) == &port) {
+					ps->erase (i);
+					break;
+				}
 			}
 
-			remove_connections_for (port);
+			/* writer goes out of scope, forces update */
 		}
 
-		return ret;
-
-	} else {
-		return -1;
+		remove_connections_for (port);
 	}
+
+	return ret;
 }
 
 int 
@@ -639,7 +668,7 @@ AudioEngine::disconnect (const string& source, const string& destination)
 }
 
 int
-AudioEngine::disconnect (Port *port)
+AudioEngine::disconnect (Port& port)
 {
 	if (!_running) {
 		if (!_has_run) {
@@ -650,7 +679,7 @@ AudioEngine::disconnect (Port *port)
 		}
 	}
 
-	int ret = jack_port_disconnect (_jack, port->_port);
+	int ret = jack_port_disconnect (_jack, port._port);
 
 	if (ret == 0) {
 		remove_connections_for (port);
@@ -660,7 +689,7 @@ AudioEngine::disconnect (Port *port)
 
 }
 
-nframes_t
+ARDOUR::nframes_t
 AudioEngine::frame_rate ()
 {
 	if (_jack) {
@@ -677,7 +706,7 @@ AudioEngine::frame_rate ()
 	}
 }
 
-nframes_t
+ARDOUR::nframes_t
 AudioEngine::frames_per_cycle ()
 {
 	if (_jack) {
@@ -694,6 +723,9 @@ AudioEngine::frames_per_cycle ()
 	}
 }
 
+/** Get a port by name.
+ * Note this can return NULL, it will NOT create a port if it is not found (any more).
+ */
 Port *
 AudioEngine::get_port_by_name (const string& portname, bool keep)
 {
@@ -708,8 +740,6 @@ AudioEngine::get_port_by_name (const string& portname, bool keep)
 		}
 	}
 	
-	/* check to see if we have a Port for this name already */
-
 	boost::shared_ptr<Ports> pr = ports.reader();
 	
 	for (Ports::iterator i = pr->begin(); i != pr->end(); ++i) {
@@ -718,26 +748,7 @@ AudioEngine::get_port_by_name (const string& portname, bool keep)
 		}
 	}
 
-	jack_port_t *p;
-
-	if ((p = jack_port_by_name (_jack, portname.c_str())) != 0) {
-		Port *newport = new Port (p);
-
-		{
-			if (keep && newport->is_mine (_jack)) {
-				RCUWriter<Ports> writer (ports);
-				boost::shared_ptr<Ports> ps = writer.get_copy ();
-				ps->insert (newport);
-				/* writer goes out of scope, forces update */
-			}
-		}
-
-		return newport;
-
-	} else {
-
-		return 0;
-	}
+	return 0;
 }
 
 const char **
@@ -854,12 +865,14 @@ AudioEngine::get_physical_outputs (vector<string>& outs)
 }
 
 string
-AudioEngine::get_nth_physical (uint32_t n, int flag)
+AudioEngine::get_nth_physical (DataType type, uint32_t n, int flag)
 {
 	const char ** ports;
 	uint32_t i;
 	string ret;
 
+	assert(type != DataType::NIL);
+
 	if (!_running || !_jack) {
 		if (!_has_run) {
 			fatal << _("get_nth_physical called before engine was started") << endmsg;
@@ -869,7 +882,7 @@ AudioEngine::get_nth_physical (uint32_t n, int flag)
 		}
 	}
 
-	ports = jack_get_ports (_jack, NULL, NULL, JackPortIsPhysical|flag);
+	ports = jack_get_ports (_jack, NULL, type.to_jack_type(), JackPortIsPhysical|flag);
 	
 	if (ports == 0) {
 		return "";
@@ -886,7 +899,7 @@ AudioEngine::get_nth_physical (uint32_t n, int flag)
 	return ret;
 }
 
-nframes_t
+ARDOUR::nframes_t
 AudioEngine::get_port_total_latency (const Port& port)
 {
 	if (!_jack) {
@@ -995,7 +1008,7 @@ AudioEngine::remove_all_ports ()
 }
 
 void
-AudioEngine::remove_connections_for (Port* port)
+AudioEngine::remove_connections_for (Port& port)
 {
 	for (PortConnections::iterator i = port_connections.begin(); i != port_connections.end(); ) {
 		PortConnections::iterator tmp;
@@ -1003,7 +1016,7 @@ AudioEngine::remove_connections_for (Port* port)
 		tmp = i;
 		++tmp;
 		
-		if ((*i).first == port->name()) {
+		if ((*i).first == port.name()) {
 			port_connections.erase (i);
 		}
 
@@ -1111,7 +1124,7 @@ AudioEngine::reconnect_to_jack ()
 		
 		short_name = long_name.substr (long_name.find_last_of (':') + 1);
 
-		if (((*i)->_port = jack_port_register (_jack, short_name.c_str(), (*i)->type(), (*i)->flags(), 0)) == 0) {
+		if (((*i)->_port = jack_port_register (_jack, short_name.c_str(), (*i)->type().to_jack_type(), (*i)->flags(), 0)) == 0) {
 			error << string_compose (_("could not reregister %1"), (*i)->name()) << endmsg;
 			break;
 		} else {
@@ -1120,7 +1133,7 @@ AudioEngine::reconnect_to_jack ()
 		(*i)->reset ();
 
 		if ((*i)->flags() & JackPortIsOutput) {
-			(*i)->silence (jack_get_buffer_size (_jack), 0);
+			(*i)->get_buffer().silence (jack_get_buffer_size (_jack), 0);
 		}
 	}
 
diff --git a/libs/ardour/audiofilesource.cc b/libs/ardour/audiofilesource.cc
index b9aa977e0a..84ccef905c 100644
--- a/libs/ardour/audiofilesource.cc
+++ b/libs/ardour/audiofilesource.cc
@@ -541,6 +541,15 @@ AudioFileSource::set_header_position_offset (nframes_t offset)
 	HeaderPositionOffsetChanged ();
 }
 
+void 
+AudioFileSource::handle_header_position_change ()
+{
+	if (writable()) {
+		set_header_timeline_position ();
+		flush_header ();
+	}
+}
+
 void
 AudioFileSource::set_timeline_position (int64_t pos)
 {
@@ -594,7 +603,8 @@ bool
 AudioFileSource::is_empty (Session& s, ustring path)
 {
 	bool ret = false;
-	boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createReadable (s, path, 0, NoPeakFile, false));
+	
+	boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createReadable (DataType::AUDIO, s, path, 0, NoPeakFile, false));
 
 	if (afs) {
 		ret = (afs->length() == 0);
diff --git a/libs/ardour/audiofilter.cc b/libs/ardour/audiofilter.cc
index d10010fbf0..d4d59d4a60 100644
--- a/libs/ardour/audiofilter.cc
+++ b/libs/ardour/audiofilter.cc
@@ -49,7 +49,8 @@ AudioFilter::make_new_sources (boost::shared_ptr<AudioRegion> region, SourceList
 		}
 
 		try {
-			nsrcs.push_back (boost::dynamic_pointer_cast<AudioSource> (SourceFactory::createWritable (session, path, false, session.frame_rate())));
+			nsrcs.push_back (boost::dynamic_pointer_cast<AudioSource> (
+				SourceFactory::createWritable (DataType::AUDIO, session, path, false, session.frame_rate())));
 		} 
 
 		catch (failed_constructor& err) {
diff --git a/libs/ardour/audioregion.cc b/libs/ardour/audioregion.cc
index 1d3032c1e0..8b4b88e100 100644
--- a/libs/ardour/audioregion.cc
+++ b/libs/ardour/audioregion.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000-2001 Paul Davis 
+    Copyright (C) 2000-2006 Paul Davis 
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -41,6 +41,7 @@
 #include <ardour/audiofilter.h>
 #include <ardour/audiofilesource.h>
 #include <ardour/region_factory.h>
+#include <ardour/runtime_functions.h>
 
 #include "i18n.h"
 #include <locale.h>
@@ -58,18 +59,13 @@ Change AudioRegion::EnvelopeActiveChanged = ARDOUR::new_change();
 Change AudioRegion::ScaleAmplitudeChanged = ARDOUR::new_change();
 Change AudioRegion::EnvelopeChanged       = ARDOUR::new_change();
 
+/** Basic AudioRegion constructor (one channel) */
 AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, nframes_t start, nframes_t length)
-	: Region (start, length, PBD::basename_nosuffix(src->name()), 0,  Region::Flag(Region::DefaultFlags|Region::External)),
+	: Region (src, start, length, PBD::basename_nosuffix(src->name()), DataType::AUDIO, 0,  Region::Flag(Region::DefaultFlags|Region::External)),
 	  _fade_in (0.0, 2.0, 1.0, false),
 	  _fade_out (0.0, 2.0, 1.0, false),
 	  _envelope (0.0, 2.0, 1.0, false)
 {
-	/* basic AudioRegion constructor */
-
-	sources.push_back (src);
-	master_sources.push_back (src);
-	src->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-
 	boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
 	if (afs) {
 		afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
@@ -83,18 +79,13 @@ AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, nframes_t start, n
 	listen_to_my_curves ();
 }
 
+/* Basic AudioRegion constructor (one channel) */
 AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
-	: Region (start, length, name, layer, flags),
-	  _fade_in (0.0, 2.0, 1.0, false),
-	  _fade_out (0.0, 2.0, 1.0, false),
-	  _envelope (0.0, 2.0, 1.0, false)
+	: Region (src, start, length, name, DataType::AUDIO, layer, flags)
+	, _fade_in (0.0, 2.0, 1.0, false)
+	, _fade_out (0.0, 2.0, 1.0, false)
+	, _envelope (0.0, 2.0, 1.0, false)
 {
-	/* basic AudioRegion constructor */
-
-	sources.push_back (src);
-	master_sources.push_back (src);
-	src->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-
 	boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
 	if (afs) {
 		afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
@@ -108,25 +99,13 @@ AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, nframes_t start, n
 	listen_to_my_curves ();
 }
 
+/* Basic AudioRegion constructor (many channels) */
 AudioRegion::AudioRegion (SourceList& srcs, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
-	: Region (start, length, name, layer, flags),
-	  _fade_in (0.0, 2.0, 1.0, false),
-	  _fade_out (0.0, 2.0, 1.0, false),
-	  _envelope (0.0, 2.0, 1.0, false)
+	: Region (srcs, start, length, name, DataType::AUDIO, layer, flags)
+	, _fade_in (0.0, 2.0, 1.0, false)
+	, _fade_out (0.0, 2.0, 1.0, false)
+	, _envelope (0.0, 2.0, 1.0, false)
 {
-	/* basic AudioRegion constructor */
-
-	for (SourceList::iterator i=srcs.begin(); i != srcs.end(); ++i) {
-		sources.push_back (*i);
-		master_sources.push_back (*i);
-		(*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-		
-		boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> ((*i));
-		if (afs) {
-			afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
-		}
-	}
-
 	_scale_amplitude = 1.0;
 
 	set_default_fades ();
@@ -136,39 +115,13 @@ AudioRegion::AudioRegion (SourceList& srcs, nframes_t start, nframes_t length, c
 }
 
 
+/** Create a new AudioRegion, that is part of an existing one */
 AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
 	: Region (other, offset, length, name, layer, flags),
 	  _fade_in (other->_fade_in),
 	  _fade_out (other->_fade_out),
 	  _envelope (other->_envelope, (double) offset, (double) offset + length) 
 {
-	/* create a new AudioRegion, that is part of an existing one */
-	
-	set<boost::shared_ptr<AudioSource> > unique_srcs;
-
-	for (SourceList::const_iterator i= other->sources.begin(); i != other->sources.end(); ++i) {
-		sources.push_back (*i);
-		(*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-
-		pair<set<boost::shared_ptr<AudioSource> >::iterator,bool> result;
-
-		result = unique_srcs.insert (*i);
-
-		if (result.second) {
-			boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (*i);
-			if (afs) {
-				afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
-			}
-		}
-	}
-
-	for (SourceList::const_iterator i = other->master_sources.begin(); i != other->master_sources.end(); ++i) {
-		if (unique_srcs.find (*i) == unique_srcs.end()) {
-			(*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-		}
-		master_sources.push_back (*i);
-	}
-
 	/* return to default fades if the existing ones are too long */
 	_fade_in_disabled = 0;
 	_fade_out_disabled = 0;
@@ -197,6 +150,8 @@ AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other, nframes_t
 	_scale_amplitude = other->_scale_amplitude;
 
 	listen_to_my_curves ();
+	
+	assert(_type == DataType::AUDIO);
 }
 
 AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other)
@@ -205,32 +160,6 @@ AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other)
 	  _fade_out (other->_fade_out),
 	  _envelope (other->_envelope) 
 {
-	/* Pure copy constructor */
-
-	set<boost::shared_ptr<AudioSource> > unique_srcs;
-
-	for (SourceList::const_iterator i = other->sources.begin(); i != other->sources.end(); ++i) {
-		sources.push_back (*i);
-		(*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-		pair<set<boost::shared_ptr<AudioSource> >::iterator,bool> result;
-
-		result = unique_srcs.insert (*i);
-
-		if (result.second) {
-			boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (*i);
-			if (afs) {
-				afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
-			}
-		}
-	}
-
-	for (SourceList::const_iterator i = other->master_sources.begin(); i != other->master_sources.end(); ++i) {
-		master_sources.push_back (*i);
-		if (unique_srcs.find (*i) == unique_srcs.end()) {
-			(*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-		}
-	}
-
 	_scale_amplitude = other->_scale_amplitude;
 	_envelope = other->_envelope;
 
@@ -238,18 +167,16 @@ AudioRegion::AudioRegion (boost::shared_ptr<const AudioRegion> other)
 	_fade_out_disabled = 0;
 	
 	listen_to_my_curves ();
+
+	assert(_type == DataType::AUDIO);
 }
 
 AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, const XMLNode& node)
-	: Region (node),
-	  _fade_in (0.0, 2.0, 1.0, false),
-	  _fade_out (0.0, 2.0, 1.0, false),
-	  _envelope (0.0, 2.0, 1.0, false)
+	: Region (src, node)
+	, _fade_in (0.0, 2.0, 1.0, false)
+	, _fade_out (0.0, 2.0, 1.0, false)
+	, _envelope (0.0, 2.0, 1.0, false)
 {
-	sources.push_back (src);
-	master_sources.push_back (src);
-	src->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-
 	boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (src);
 	if (afs) {
 		afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
@@ -262,38 +189,16 @@ AudioRegion::AudioRegion (boost::shared_ptr<AudioSource> src, const XMLNode& nod
 	}
 
 	listen_to_my_curves ();
+
+	assert(_type == DataType::AUDIO);
 }
 
 AudioRegion::AudioRegion (SourceList& srcs, const XMLNode& node)
-	: Region (node),
+	: Region (srcs, node),
 	  _fade_in (0.0, 2.0, 1.0, false),
 	  _fade_out (0.0, 2.0, 1.0, false),
 	  _envelope (0.0, 2.0, 1.0, false)
 {
-	set<boost::shared_ptr<AudioSource> > unique_srcs;
-
-	for (SourceList::iterator i=srcs.begin(); i != srcs.end(); ++i) {
-		sources.push_back (*i);
-		(*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-		pair<set<boost::shared_ptr<AudioSource> >::iterator,bool> result;
-
-		result = unique_srcs.insert (*i);
-
-		if (result.second) {
-			boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (*i);
-			if (afs) {
-				afs->HeaderPositionOffsetChanged.connect (mem_fun (*this, &AudioRegion::source_offset_changed));
-			}
-		}
-	}
-
-	for (SourceList::iterator i = srcs.begin(); i != srcs.end(); ++i) {
-		master_sources.push_back (*i);
-		if (unique_srcs.find (*i) == unique_srcs.end()) {
-			(*i)->GoingAway.connect (mem_fun (*this, &AudioRegion::source_deleted));
-		}
-	}
-
 	set_default_fades ();
 	_scale_amplitude = 1.0;
 
@@ -302,20 +207,12 @@ AudioRegion::AudioRegion (SourceList& srcs, const XMLNode& node)
 	}
 
 	listen_to_my_curves ();
+
+	assert(_type == DataType::AUDIO);
 }
 
 AudioRegion::~AudioRegion ()
 {
-	boost::shared_ptr<Playlist> pl (playlist());
-
-	if (pl) {
-		for (SourceList::const_iterator i = sources.begin(); i != sources.end(); ++i) {
-			(*i)->remove_playlist (pl);
-		}
-	}
-
-	notify_callbacks ();
-	GoingAway (); /* EMIT SIGNAL */
 }
 
 void
@@ -333,14 +230,9 @@ AudioRegion::verify_length (nframes_t len)
 
 	if (afs && afs->destructive()) {
 		return true;
+	} else {
+		return Region::verify_length(len);
 	}
-
-	for (uint32_t n=0; n < sources.size(); ++n) {
-		if (_start > sources[n]->length() - len) {
-			return false;
-		}
-	}
-	return true;
 }
 
 bool
@@ -350,15 +242,11 @@ AudioRegion::verify_start_and_length (nframes_t new_start, nframes_t new_length)
 
 	if (afs && afs->destructive()) {
 		return true;
+	} else {
+		return Region::verify_start_and_length(new_start, new_length);
 	}
-
-	for (uint32_t n=0; n < sources.size(); ++n) {
-		if (new_length > sources[n]->length() - new_start) {
-			return false;
-		}
-	}
-	return true;
 }
+
 bool
 AudioRegion::verify_start (nframes_t pos)
 {
@@ -366,14 +254,9 @@ AudioRegion::verify_start (nframes_t pos)
 
 	if (afs && afs->destructive()) {
 		return true;
+	} else {
+		return Region::verify_start(pos);
 	}
-
-	for (uint32_t n=0; n < sources.size(); ++n) {
-		if (pos > sources[n]->length() - _length) {
-			return false;
-		}
-	}
-	return true;
 }
 
 bool
@@ -383,15 +266,11 @@ AudioRegion::verify_start_mutable (nframes_t& new_start)
 
 	if (afs && afs->destructive()) {
 		return true;
+	} else {
+		return Region::verify_start_mutable(new_start);
 	}
-
-	for (uint32_t n=0; n < sources.size(); ++n) {
-		if (new_start > sources[n]->length() - _length) {
-			new_start = sources[n]->length() - _length;
-		}
-	}
-	return true;
 }
+
 void
 AudioRegion::set_envelope_active (bool yn)
 {
@@ -408,14 +287,14 @@ AudioRegion::set_envelope_active (bool yn)
 	}
 }
 
-nframes_t
+ARDOUR::nframes_t
 AudioRegion::read_peaks (PeakData *buf, nframes_t npeaks, nframes_t offset, nframes_t cnt, uint32_t chan_n, double samples_per_unit) const
 {
-	if (chan_n >= sources.size()) {
+	if (chan_n >= _sources.size()) {
 		return 0; 
 	}
 
-	if (sources[chan_n]->read_peaks (buf, npeaks, offset, cnt, samples_per_unit)) {
+	if (audio_source(chan_n)->read_peaks (buf, npeaks, offset, cnt, samples_per_unit)) {
 		return 0;
 	} else {
 		if (_scale_amplitude != 1.0) {
@@ -428,26 +307,28 @@ AudioRegion::read_peaks (PeakData *buf, nframes_t npeaks, nframes_t offset, nfra
 	}
 }
 
-nframes_t
+ARDOUR::nframes_t
 AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t position, 
 		      nframes_t cnt, 
 		      uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
 {
-	return _read_at (sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, read_frames, skip_frames);
+	return _read_at (_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, read_frames, skip_frames);
 }
 
-nframes_t
+ARDOUR::nframes_t
 AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, nframes_t position, 
 			     nframes_t cnt, uint32_t chan_n) const
 {
-	return _read_at (master_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0);
+	return _read_at (_master_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0);
 }
 
-nframes_t
+ARDOUR::nframes_t
 AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buffer, float *gain_buffer,
 		       nframes_t position, nframes_t cnt, 
 		       uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
 {
+	// cerr << _name << "._read_at(" << position << ") - " << _position << endl;
+
 	nframes_t internal_offset;
 	nframes_t buf_offset;
 	nframes_t to_read;
@@ -485,13 +366,14 @@ AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buff
 	_read_data_count = 0;
 
 	if (chan_n < n_channels()) {
+		
+		boost::shared_ptr<AudioSource> src = audio_source(chan_n);
+		if (src->read (mixdown_buffer, _start + internal_offset, to_read) != to_read) {
 
-		if (srcs[chan_n]->read (mixdown_buffer, _start + internal_offset, to_read) != to_read) {
-			
 			return 0; /* "read nothing" */
 		}
-		
-		_read_data_count += srcs[chan_n]->read_data_count();
+
+		_read_data_count += src->read_data_count();
 
 	} else {
 		
@@ -586,7 +468,7 @@ AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buff
 			}
 		}
 	} else if (_scale_amplitude != 1.0f) {
-		Session::apply_gain_to_buffer (mixdown_buffer, to_read, _scale_amplitude);
+		apply_gain_to_buffer (mixdown_buffer, to_read, _scale_amplitude);
 	}
 
   merge:
@@ -620,13 +502,13 @@ AudioRegion::state (bool full)
 	snprintf (buf, sizeof(buf), "%.12g", _scale_amplitude);
 	node.add_property ("scale-gain", buf);
 
-	for (uint32_t n=0; n < sources.size(); ++n) {
+	for (uint32_t n=0; n < _sources.size(); ++n) {
 		snprintf (buf2, sizeof(buf2), "source-%d", n);
-		sources[n]->id().print (buf, sizeof (buf));
+		_sources[n]->id().print (buf, sizeof (buf));
 		node.add_property (buf2, buf);
 	}
 
-	snprintf (buf, sizeof (buf), "%u", (uint32_t) sources.size());
+	snprintf (buf, sizeof (buf), "%u", (uint32_t) _sources.size());
 	node.add_property ("channels", buf);
 
 	if (full) {
@@ -1051,20 +933,20 @@ AudioRegion::separate_by_channel (Session& session, vector<boost::shared_ptr<Aud
 	string new_name;
 	int n;
 
-	if (sources.size() < 2) {
+	if (_sources.size() < 2) {
 		return 0;
 	}
 
 	n = 0;
 
-	for (SourceList::const_iterator i = sources.begin(); i != sources.end(); ++i) {
+	for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
 
 		srcs.clear ();
 		srcs.push_back (*i);
 
 		new_name = _name;
 
-		if (sources.size() == 2) {
+		if (_sources.size() == 2) {
 			if (n == 0) {
 				new_name += "-L";
 			} else {
@@ -1092,52 +974,6 @@ AudioRegion::separate_by_channel (Session& session, vector<boost::shared_ptr<Aud
 	return 0;
 }
 
-void
-AudioRegion::source_deleted ()
-{
-	sources.clear ();
-	drop_references ();
-}
-
-vector<string>
-AudioRegion::master_source_names ()
-{
-	SourceList::iterator i;
-
-	vector<string> names;
-	for (i = master_sources.begin(); i != master_sources.end(); ++i) {
-		names.push_back((*i)->name());
-	}
-
-	return names;
-}
-
-bool
-AudioRegion::source_equivalent (boost::shared_ptr<const Region> o) const
-{
-	boost::shared_ptr<const AudioRegion> other = boost::dynamic_pointer_cast<const AudioRegion>(o);
-
-	if (!other)
-		return false;
-
-	SourceList::const_iterator i;
-	SourceList::const_iterator io;
-
-	for (i = sources.begin(), io = other->sources.begin(); i != sources.end() && io != other->sources.end(); ++i, ++io) {
-		if ((*i)->id() != (*io)->id()) {
-			return false;
-		}
-	}
-
-	for (i = master_sources.begin(), io = other->master_sources.begin(); i != master_sources.end() && io != other->master_sources.end(); ++i, ++io) {
-		if ((*i)->id() != (*io)->id()) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
 int
 AudioRegion::apply (AudioFilter& filter)
 {
@@ -1152,7 +988,7 @@ AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
 	nframes_t to_read;
 	int status = -1;
 
-	spec.channels = sources.size();
+	spec.channels = _sources.size();
 
 	if (spec.prepare (blocksize, session.frame_rate())) {
 		goto out;
@@ -1170,7 +1006,7 @@ AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
 		
 		if (spec.channels == 1) {
 
-			if (sources.front()->read (spec.dataF, _start + spec.pos, to_read) != to_read) {
+			if (audio_source()->read (spec.dataF, _start + spec.pos, to_read) != to_read) {
 				goto out;
 			}
 
@@ -1180,7 +1016,7 @@ AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
 
 			for (uint32_t chan = 0; chan < spec.channels; ++chan) {
 				
-				if (sources[chan]->read (buf, _start + spec.pos, to_read) != to_read) {
+				if (audio_source(chan)->read (buf, _start + spec.pos, to_read) != to_read) {
 					goto out;
 				}
 				
@@ -1209,23 +1045,6 @@ AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
 	return status;
 }
 
-boost::shared_ptr<Region>
-AudioRegion::get_parent() const
-{
-	boost::shared_ptr<Playlist> pl (playlist());
-
-	if (pl) {
-		boost::shared_ptr<AudioRegion> ar;
-		boost::shared_ptr<AudioRegion const> grrr2 = boost::dynamic_pointer_cast<AudioRegion const> (shared_from_this());
-		
-		if (grrr2 && (ar = pl->session().find_whole_file_parent (grrr2))) {
-			return boost::static_pointer_cast<Region> (ar);
-		}
-	}
-	
-	return boost::shared_ptr<Region>();
-}
-
 void
 AudioRegion::set_scale_amplitude (gain_t g)
 {
@@ -1277,11 +1096,11 @@ AudioRegion::normalize_to (float target_dB)
 
 			/* read it in */
 
-			if (source (n)->read (buf, fpos, to_read) != to_read) {
+			if (audio_source (n)->read (buf, fpos, to_read) != to_read) {
 				return;
 			}
 			
-			maxamp = Session::compute_peak (buf, to_read, maxamp);
+			maxamp = compute_peak (buf, to_read, maxamp);
 		}
 
 		fpos += to_read;
@@ -1371,12 +1190,12 @@ AudioRegion::resume_fade_out ()
 bool
 AudioRegion::speed_mismatch (float sr) const
 {
-	if (sources.empty()) {
+	if (_sources.empty()) {
 		/* impossible, but ... */
 		return false;
 	}
 
-	float fsr = sources.front()->sample_rate();
+	float fsr = audio_source()->sample_rate();
 
 	return fsr != sr;
 }
@@ -1384,7 +1203,7 @@ AudioRegion::speed_mismatch (float sr) const
 void
 AudioRegion::source_offset_changed ()
 {
-	boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(sources.front());
+	boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(_sources.front());
 
 	if (afs && afs->destructive()) {
 		// set_start (source()->natural_position(), this);
@@ -1392,37 +1211,11 @@ AudioRegion::source_offset_changed ()
 	} 
 }
 
-void
-AudioRegion::set_playlist (boost::weak_ptr<Playlist> wpl)
+boost::shared_ptr<AudioSource>
+AudioRegion::audio_source (uint32_t n) const
 {
-	boost::shared_ptr<Playlist> old_playlist = (_playlist.lock());
-
-	boost::shared_ptr<Playlist> pl (wpl.lock());
-
-	if (old_playlist == pl) {
-		return;
-	}
-
-	Region::set_playlist (wpl);
-
-	if (pl) {
-		if (old_playlist) {
-			for (SourceList::const_iterator i = sources.begin(); i != sources.end(); ++i) {
-				(*i)->remove_playlist (_playlist);	
-				(*i)->add_playlist (pl);
-			}
-		} else {
-			for (SourceList::const_iterator i = sources.begin(); i != sources.end(); ++i) {
-				(*i)->add_playlist (pl);
-			}
-		}
-	} else {
-		if (old_playlist) {
-			for (SourceList::const_iterator i = sources.begin(); i != sources.end(); ++i) {
-				(*i)->remove_playlist (old_playlist);
-			}
-		}
-	}
+	// Guaranteed to succeed (use a static cast for speed?)
+	return boost::dynamic_pointer_cast<AudioSource>(source(n));
 }
 
 extern "C" {
@@ -1440,7 +1233,7 @@ uint32_t region_length_from_c (void *arg)
 
 uint32_t sourcefile_length_from_c (void *arg, double zoom_factor)
 {
-	return ( (AudioRegion *) arg)->source()->available_peaks (zoom_factor) ;
+	return ( (AudioRegion *) arg)->audio_source()->available_peaks (zoom_factor) ;
 }
 
 } /* extern "C" */
diff --git a/libs/ardour/audiosource.cc b/libs/ardour/audiosource.cc
index 0043df7d2e..49cfc15a54 100644
--- a/libs/ardour/audiosource.cc
+++ b/libs/ardour/audiosource.cc
@@ -35,7 +35,7 @@
 
 #include <ardour/audiosource.h>
 #include <ardour/cycle_timer.h>
-#include <ardour/session.h>
+#include <ardour/runtime_functions.h>
 
 #include "i18n.h"
 
@@ -47,7 +47,7 @@ bool AudioSource::_build_missing_peakfiles = false;
 bool AudioSource::_build_peakfiles = false;
 
 AudioSource::AudioSource (Session& s, ustring name)
-	: Source (s, name)
+	: Source (s, name, DataType::AUDIO)
 {
 	_peaks_built = false;
 	_peak_byte_max = 0;
@@ -696,7 +696,7 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 			
 			x.min = peak_leftovers[0];
 			x.max = peak_leftovers[0];
-			Session::find_peaks (peak_leftovers + 1, peak_leftover_cnt - 1, &x.min, &x.max);
+			find_peaks (peak_leftovers + 1, peak_leftover_cnt - 1, &x.min, &x.max);
 
 			off_t byte = (peak_leftover_frame / frames_per_peak) * sizeof (PeakData);
 
@@ -779,7 +779,7 @@ AudioSource::compute_and_write_peaks (Sample* buf, nframes_t first_frame, nframe
 		peakbuf[peaks_computed].max = buf[0];
 		peakbuf[peaks_computed].min = buf[0];
 
-		Session::find_peaks (buf+1, this_time-1, &peakbuf[peaks_computed].min, &peakbuf[peaks_computed].max);
+		find_peaks (buf+1, this_time-1, &peakbuf[peaks_computed].min, &peakbuf[peaks_computed].max);
 
 		peaks_computed++;
 		buf += this_time;
@@ -883,11 +883,3 @@ AudioSource::available_peaks (double zoom_factor) const
 	return (end/sizeof(PeakData)) * frames_per_peak;
 }
 
-void
-AudioSource::update_length (nframes_t pos, nframes_t cnt)
-{
-	if (pos + cnt > _length) {
-		_length = pos+cnt;
-	}
-}
-
diff --git a/libs/ardour/auditioner.cc b/libs/ardour/auditioner.cc
index e6f4e12e3d..0ba30b2b8b 100644
--- a/libs/ardour/auditioner.cc
+++ b/libs/ardour/auditioner.cc
@@ -45,11 +45,11 @@ Auditioner::Auditioner (Session& s)
 	string right = Config->get_auditioner_output_right();
 
 	if (left == "default") {
-		left = _session.engine().get_nth_physical_output (0);	
+		left = _session.engine().get_nth_physical_output (DataType::AUDIO, 0);	
 	}
 
 	if (right == "default") {
-		right = _session.engine().get_nth_physical_output (1);
+		right = _session.engine().get_nth_physical_output (DataType::AUDIO, 1);
 	}
 	
 	if ((left.length() == 0) && (right.length() == 0)) {
@@ -70,6 +70,8 @@ Auditioner::Auditioner (Session& s)
 
 	allow_pan_reset ();
 	
+	reset_panner ();
+
 	IO::output_changed.connect (mem_fun (*this, &Auditioner::output_changed));
 
 	the_region.reset ((AudioRegion*) 0);
@@ -108,7 +110,7 @@ Auditioner::audition_current_playlist ()
 
 	/* force a panner reset now that we have all channels */
 
-	_panner->reset (n_outputs(), _diskstream->n_channels());
+	_panner->reset (n_outputs().get(DataType::AUDIO), _diskstream->n_channels().get(DataType::AUDIO));
 
 	g_atomic_int_set (&_active, 1);
 }
@@ -138,15 +140,15 @@ Auditioner::audition_region (boost::shared_ptr<Region> region)
 	_diskstream->playlist()->clear ();
 	_diskstream->playlist()->add_region (the_region, 0, 1);
 
-	if (_diskstream->n_channels() < the_region->n_channels()) {
-		audio_diskstream()->add_channel (the_region->n_channels() - _diskstream->n_channels());
-	} else if (_diskstream->n_channels() > the_region->n_channels()) {
-		audio_diskstream()->remove_channel (_diskstream->n_channels() - the_region->n_channels());
+	if (_diskstream->n_channels().get(DataType::AUDIO) < the_region->n_channels()) {
+		audio_diskstream()->add_channel (the_region->n_channels() - _diskstream->n_channels().get(DataType::AUDIO));
+	} else if (_diskstream->n_channels().get(DataType::AUDIO) > the_region->n_channels()) {
+		audio_diskstream()->remove_channel (_diskstream->n_channels().get(DataType::AUDIO) - the_region->n_channels());
 	}
 
 	/* force a panner reset now that we have all channels */
 
-	_panner->reset (n_outputs(), _diskstream->n_channels());
+	reset_panner();
 
 	length = the_region->length();
 	_diskstream->seek (0);
@@ -195,7 +197,7 @@ Auditioner::output_changed (IOChange change, void* src)
 		const char ** connections;
 		connections =  output (0)->get_connections ();
 		if (connections) {
-			phys = _session.engine().get_nth_physical_output (0);
+			phys = _session.engine().get_nth_physical_output (DataType::AUDIO, 0);
 			if (phys != connections[0]) {
 				Config->set_auditioner_output_left (connections[0]);
 			} else {
@@ -208,7 +210,7 @@ Auditioner::output_changed (IOChange change, void* src)
 		
 		connections = output (1)->get_connections ();
 		if (connections) {
-			phys = _session.engine().get_nth_physical_output (1);
+			phys = _session.engine().get_nth_physical_output (DataType::AUDIO, 1);
 			if (phys != connections[0]) {
 				Config->set_auditioner_output_right (connections[0]);
 			} else {
diff --git a/libs/ardour/automation_event.cc b/libs/ardour/automation_event.cc
index 341fa82091..cfac2e445f 100644
--- a/libs/ardour/automation_event.cc
+++ b/libs/ardour/automation_event.cc
@@ -1335,7 +1335,7 @@ AutomationList::set_state (const XMLNode& node)
 		const XMLNodeList& elist = node.children();
 		XMLNodeConstIterator i;
 		XMLProperty* prop;
-		jack_nframes_t x;
+		nframes_t x;
 		double y;
 		
 		freeze ();
diff --git a/libs/ardour/buffer.cc b/libs/ardour/buffer.cc
new file mode 100644
index 0000000000..7635ea2199
--- /dev/null
+++ b/libs/ardour/buffer.cc
@@ -0,0 +1,171 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <algorithm>
+#include <iostream>
+using std::cerr; using std::endl;
+
+#include <ardour/buffer.h>
+
+#ifdef __x86_64__
+static const int CPU_CACHE_ALIGN = 64;
+#else
+static const int CPU_CACHE_ALIGN = 16; /* arguably 32 on most arches, but it matters less */
+#endif
+
+namespace ARDOUR {
+
+
+Buffer*
+Buffer::create(DataType type, size_t capacity)
+{
+	if (type == DataType::AUDIO)
+		return new AudioBuffer(capacity);
+	else if (type == DataType::MIDI)
+		return new MidiBuffer(capacity);
+	else
+		return NULL;
+}
+
+
+AudioBuffer::AudioBuffer(size_t capacity)
+	: Buffer(DataType::AUDIO, capacity)
+	, _owns_data(false)
+	, _data(NULL)
+{
+	_size = capacity; // For audio buffers, size = capacity (always)
+	if (capacity > 0) {
+#ifdef NO_POSIX_MEMALIGN
+		_data =  (Sample *) malloc(sizeof(Sample) * capacity);
+#else
+		posix_memalign((void**)&_data, CPU_CACHE_ALIGN, sizeof(Sample) * capacity);
+#endif	
+		assert(_data);
+		_owns_data = true;
+		clear();
+	}
+}
+
+AudioBuffer::~AudioBuffer()
+{
+	if (_owns_data)
+		free(_data);
+}
+
+// FIXME: mirroring for MIDI buffers?
+MidiBuffer::MidiBuffer(size_t capacity)
+	: Buffer(DataType::MIDI, capacity)
+//	, _owns_data(true)
+	, _events(NULL)
+	, _data(NULL)
+{
+	assert(capacity > 0);
+
+	_size = 0;
+
+#ifdef NO_POSIX_MEMALIGN
+	_events =  (MidiEvent *) malloc(sizeof(MidiEvent) * capacity);
+	_data =  (RawMidi *) malloc(sizeof(RawMidi) * capacity * MAX_EVENT_SIZE);
+#else
+	posix_memalign((void**)&_events, CPU_CACHE_ALIGN, sizeof(MidiEvent) * capacity);
+	posix_memalign((void**)&_data, CPU_CACHE_ALIGN, sizeof(RawMidi) * capacity * MAX_EVENT_SIZE);
+#endif	
+	assert(_data);
+	assert(_events);
+	silence(_capacity);
+}
+
+MidiBuffer::~MidiBuffer()
+{
+	free(_events);
+	free(_data);
+}
+
+
+/** Read events from @a src starting at time @a offset into the START of this buffer, for
+ * time direction @a nframes.  Relative time, where 0 = start of buffer.
+ *
+ * Note that offset and nframes refer to sample time, NOT buffer offsets or event counts.
+ */
+void
+MidiBuffer::read_from(const Buffer& src, nframes_t nframes, nframes_t offset)
+{
+	assert(src.type() == DataType::MIDI);
+	const MidiBuffer& msrc = (MidiBuffer&)src;
+
+	assert(_capacity >= src.size());
+
+	clear();
+	assert(_size == 0);
+
+	// FIXME: slow
+	for (size_t i=0; i < src.size(); ++i) {
+		const MidiEvent& ev = msrc[i];
+		if (ev.time >= offset && ev.time < offset+nframes) {
+			push_back(ev);
+		}
+	}
+
+	_silent = src.silent();
+}
+
+
+/** Push an event into the buffer.
+ *
+ * Note that the raw MIDI pointed to by ev will be COPIED and unmodified.
+ * That is, the caller still owns it, if it needs freeing it's Not My Problem(TM).
+ * Realtime safe.
+ * @return false if operation failed (not enough room)
+ */
+bool
+MidiBuffer::push_back(const MidiEvent& ev)
+{
+	if (_size == _capacity)
+		return false;
+
+	RawMidi* const write_loc = _data + (_size * MAX_EVENT_SIZE);
+
+	memcpy(write_loc, ev.buffer, ev.size);
+	_events[_size] = ev;
+	_events[_size].buffer = write_loc;
+	++_size;
+
+	//cerr << "MidiBuffer: pushed, size = " << _size << endl;
+
+	_silent = false;
+
+	return true;
+}
+
+
+void
+MidiBuffer::silence(nframes_t dur, nframes_t offset)
+{
+	// FIXME use parameters
+	assert(offset == 0);
+	//assert(dur == _capacity);
+
+	memset(_events, 0, sizeof(MidiEvent) * _capacity);
+	memset(_data, 0, sizeof(RawMidi) * _capacity * MAX_EVENT_SIZE);
+	_size = 0;
+	_silent = true;
+}
+
+
+} // namespace ARDOUR
+
diff --git a/libs/ardour/buffer_set.cc b/libs/ardour/buffer_set.cc
new file mode 100644
index 0000000000..24af224845
--- /dev/null
+++ b/libs/ardour/buffer_set.cc
@@ -0,0 +1,170 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <algorithm>
+#include <ardour/buffer_set.h>
+#include <ardour/buffer.h>
+#include <ardour/port.h>
+#include <ardour/port_set.h>
+
+namespace ARDOUR {
+
+/** Create a new, empty BufferSet */
+BufferSet::BufferSet()
+	: _is_mirror(false)
+{
+	for (size_t i=0; i < DataType::num_types; ++i)
+		_buffers.push_back( BufferVec() );
+
+	_count.reset();
+	_available.reset();
+}
+
+BufferSet::~BufferSet()
+{
+	clear();
+}
+
+/** Destroy all contained buffers.
+ */
+void
+BufferSet::clear()
+{
+	if (!_is_mirror) {
+		for (std::vector<BufferVec>::iterator i = _buffers.begin(); i != _buffers.end(); ++i) {
+			for (BufferVec::iterator j = (*i).begin(); j != (*i).end(); ++j) {
+				delete *j;
+			}
+			(*i).clear();
+		}
+	}
+	_buffers.clear();
+	_count.reset();
+	_available.reset();
+}
+
+/** Make this BufferSet a direct mirror of a PortSet's buffers.
+ */
+void
+BufferSet::attach_buffers(PortSet& ports)
+{
+	clear();
+
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+		_buffers.push_back(BufferVec());
+		BufferVec& v = _buffers[(*t).to_index()];
+
+		for (PortSet::iterator p = ports.begin(*t); p != ports.end(*t); ++p) {
+			assert(p->type() == *t);
+			v.push_back(&(p->get_buffer()));
+		}
+
+	}
+	
+	_count = ports.count();
+
+	_is_mirror = true;
+}
+
+void
+BufferSet::ensure_buffers(const ChanCount& count, size_t buffer_capacity)
+{
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+		ensure_buffers(*t, count.get(*t), buffer_capacity);
+	}
+}
+
+
+/** Ensure that there are @a num_buffers buffers of type @a type available,
+ * each of size at least @a buffer_size
+ */
+void
+BufferSet::ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capacity)
+{
+	assert(type != DataType::NIL);
+	assert(type.to_index() < _buffers.size());
+
+	if (num_buffers == 0)
+		return;
+
+	// The vector of buffers of the type we care about
+	BufferVec& bufs = _buffers[type.to_index()];
+	
+	// If we're a mirror just make sure we're ok
+	if (_is_mirror) {
+		assert(_count.get(type) >= num_buffers);
+		assert(bufs[0]->type() == type);
+		return;
+	}
+
+	// If there's not enough or they're too small, just nuke the whole thing and
+	// rebuild it (so I'm lazy..)
+	if (bufs.size() < num_buffers
+			|| (bufs.size() > 0 && bufs[0]->capacity() < buffer_capacity)) {
+
+		// Nuke it
+		for (BufferVec::iterator i = bufs.begin(); i != bufs.end(); ++i) {
+			delete (*i);
+		}
+		bufs.clear();
+
+		// Rebuild it
+		for (size_t i=0; i < num_buffers; ++i) {
+			bufs.push_back(Buffer::create(type, buffer_capacity));
+		}
+	
+		_available.set(type, num_buffers);
+	}
+
+	// Post-conditions
+	assert(bufs[0]->type() == type);
+	assert(bufs.size() >= num_buffers);
+	assert(bufs.size() == _available.get(type));
+	assert(bufs[0]->capacity() >= buffer_capacity);
+}
+
+/** Get the capacity (size) of the available buffers of the given type.
+ *
+ * All buffers of a certain type always have the same capacity.
+ */
+size_t
+BufferSet::buffer_capacity(DataType type) const
+{
+	assert(_available.get(type) > 0);
+	return _buffers[type.to_index()][0]->capacity();
+}
+
+// FIXME: make 'in' const
+void
+BufferSet::read_from(BufferSet& in, nframes_t nframes, nframes_t offset)
+{
+	assert(available() >= in.count());
+
+	// Copy all buffers 1:1
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+		BufferSet::iterator o = begin(*t);
+		for (BufferSet::iterator i = in.begin(*t); i != in.end(*t); ++i, ++o) {
+			o->read_from(*i, nframes, offset);
+		}
+	}
+
+	set_count(in.count());
+}
+
+} // namespace ARDOUR
+
diff --git a/libs/ardour/chan_count.cc b/libs/ardour/chan_count.cc
new file mode 100644
index 0000000000..269f985796
--- /dev/null
+++ b/libs/ardour/chan_count.cc
@@ -0,0 +1,48 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: insert.cc 712 2006-07-28 01:08:57Z drobilla $
+*/
+
+#define __STDC_LIMIT_MACROS 1
+#include <stdint.h>
+#include <ardour/chan_count.h>
+
+namespace ARDOUR {
+
+// infinite/zero chan count stuff, for setting minimums and maximums, etc.
+// FIXME: implement this in a less fugly way
+
+ChanCount
+infinity_factory()
+{
+	ChanCount ret;
+
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+		ret.set(*t, SIZE_MAX);
+	}
+
+	return ret;
+}
+
+
+// Statics
+const ChanCount ChanCount::INFINITE = infinity_factory();
+const ChanCount ChanCount::ZERO     = ChanCount();
+
+
+} // namespace ARDOUR
diff --git a/libs/ardour/control_protocol_manager.cc b/libs/ardour/control_protocol_manager.cc
index c79aa74698..00c05b2800 100644
--- a/libs/ardour/control_protocol_manager.cc
+++ b/libs/ardour/control_protocol_manager.cc
@@ -96,8 +96,10 @@ ControlProtocolManager::drop_session ()
 		
 		for (list<ControlProtocolInfo*>::iterator p = control_protocol_info.begin(); p != control_protocol_info.end(); ++p) {
 			// otherwise the ControlProtocol instances are not recreated in set_session
-			(*p)->requested = true;
-			(*p)->protocol = 0;
+			if ((*p)->protocol) {
+				(*p)->requested = true;
+				(*p)->protocol = 0;
+			}
 		}
 	}
 }
diff --git a/libs/ardour/crossfade.cc b/libs/ardour/crossfade.cc
index c217b76422..f142d57628 100644
--- a/libs/ardour/crossfade.cc
+++ b/libs/ardour/crossfade.cc
@@ -155,8 +155,6 @@ Crossfade::Crossfade (const Playlist& playlist, XMLNode& node)
 	}
 
 	_length = 0;
-	_active = Config->get_xfades_active();
-
 	initialize();
 	
 	if (set_state (node)) {
diff --git a/libs/ardour/diskstream.cc b/libs/ardour/diskstream.cc
index c9c11cc92d..18aeb32931 100644
--- a/libs/ardour/diskstream.cc
+++ b/libs/ardour/diskstream.cc
@@ -61,7 +61,7 @@ using namespace PBD;
  * default from configuration_vars.h).  0 is not a good value for
  * allocating buffer sizes..
  */
-nframes_t Diskstream::disk_io_chunk_frames = 1024 * 256;
+ARDOUR::nframes_t Diskstream::disk_io_chunk_frames = 1024 * 256;
 
 sigc::signal<void>                Diskstream::DiskOverrun;
 sigc::signal<void>                Diskstream::DiskUnderrun;
@@ -120,8 +120,6 @@ Diskstream::init (Flag f)
 	overwrite_frame = 0;
 	overwrite_queued = false;
 	input_change_pending = NoChange;
-
-	_n_channels = 0;
 }
 
 Diskstream::~Diskstream ()
@@ -261,7 +259,7 @@ Diskstream::set_loop (Location *location)
 	return 0;
 }
 
-nframes_t
+ARDOUR::nframes_t
 Diskstream::get_capture_start_frame (uint32_t n)
 {
 	Glib::Mutex::Lock lm (capture_info_lock);
@@ -274,7 +272,7 @@ Diskstream::get_capture_start_frame (uint32_t n)
 	}
 }
 
-nframes_t
+ARDOUR::nframes_t
 Diskstream::get_captured_frames (uint32_t n)
 {
 	Glib::Mutex::Lock lm (capture_info_lock);
@@ -288,7 +286,7 @@ Diskstream::get_captured_frames (uint32_t n)
 }
 
 void
-Diskstream::set_roll_delay (nframes_t nframes)
+Diskstream::set_roll_delay (ARDOUR::nframes_t nframes)
 {
 	_roll_delay = nframes;
 }
diff --git a/libs/ardour/globals.cc b/libs/ardour/globals.cc
index 2d22f4eb11..fcebe92dce 100644
--- a/libs/ardour/globals.cc
+++ b/libs/ardour/globals.cc
@@ -14,7 +14,6 @@
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
 */
 
 #include <cstdio> // Needed so that libraptor (included in lrdf) won't complain
@@ -48,12 +47,14 @@
 #include <ardour/utils.h>
 #include <ardour/session.h>
 #include <ardour/control_protocol_manager.h>
+#include <ardour/audioengine.h>
 
 #ifdef HAVE_LIBLO
 #include <ardour/osc.h>
 #endif
 
 #include <ardour/mix.h>
+#include <ardour/runtime_functions.h>
 
 #if defined (__APPLE__)
        #include <Carbon/Carbon.h> // For Gestalt
@@ -83,6 +84,12 @@ Change ARDOUR::PositionChanged = ARDOUR::new_change ();
 Change ARDOUR::NameChanged = ARDOUR::new_change ();
 Change ARDOUR::BoundsChanged = Change (0); // see init(), below
 
+compute_peak_t			ARDOUR::compute_peak 		= 0;
+find_peaks_t			ARDOUR::find_peaks 		= 0;
+apply_gain_to_buffer_t		ARDOUR::apply_gain_to_buffer 	= 0;
+mix_buffers_with_gain_t	        ARDOUR::mix_buffers_with_gain 	= 0;
+mix_buffers_no_gain_t		ARDOUR::mix_buffers_no_gain 	= 0;
+
 #ifdef HAVE_LIBLO
 static int
 setup_osc ()
@@ -101,8 +108,8 @@ setup_osc ()
 }
 #endif
 
-static int 
-setup_midi ()
+int 
+ARDOUR::setup_midi (AudioEngine& engine)
 {
 	std::map<string,Configuration::MidiPortDescriptor*>::iterator i;
 	int nports;
@@ -112,6 +119,8 @@ setup_midi ()
 		return 0;
 	}
 
+	MIDI::Manager::instance()->set_api_data(engine.jack());
+
 	for (i = Config->midi_ports.begin(); i != Config->midi_ports.end(); ++i) {
 		Configuration::MidiPortDescriptor* port_descriptor;
 
@@ -191,7 +200,7 @@ setup_midi ()
 
 	return 0;
 }
-
+	
 void
 setup_hardware_optimization (bool try_optimization)
 {
@@ -234,11 +243,11 @@ setup_hardware_optimization (bool try_optimization)
 			info << "Using SSE optimized routines" << endmsg;
 	
 			// SSE SET
-			Session::compute_peak 		= x86_sse_compute_peak;
-			Session::find_peaks 		= x86_sse_find_peaks;
-			Session::apply_gain_to_buffer 	= x86_sse_apply_gain_to_buffer;
-			Session::mix_buffers_with_gain 	= x86_sse_mix_buffers_with_gain;
-			Session::mix_buffers_no_gain 	= x86_sse_mix_buffers_no_gain;
+			compute_peak 		= x86_sse_compute_peak;
+			find_peaks 		= x86_sse_find_peaks;
+			apply_gain_to_buffer 	= x86_sse_apply_gain_to_buffer;
+			mix_buffers_with_gain 	= x86_sse_mix_buffers_with_gain;
+			mix_buffers_no_gain 	= x86_sse_mix_buffers_no_gain;
 
 			generic_mix_functions = false;
 
@@ -251,11 +260,11 @@ setup_hardware_optimization (bool try_optimization)
                         sysVersion = 0;
 
                 if (sysVersion >= 0x00001040) { // Tiger at least
-                        Session::compute_peak           = veclib_compute_peak;
-			Session::find_peaks 		= veclib_find_peaks;
-                        Session::apply_gain_to_buffer   = veclib_apply_gain_to_buffer;
-                        Session::mix_buffers_with_gain  = veclib_mix_buffers_with_gain;
-                        Session::mix_buffers_no_gain    = veclib_mix_buffers_no_gain;
+                        compute_peak           = veclib_compute_peak;
+			find_peaks 	       = veclib_find_peaks;
+                        apply_gain_to_buffer   = veclib_apply_gain_to_buffer;
+                        mix_buffers_with_gain  = veclib_mix_buffers_with_gain;
+                        mix_buffers_no_gain    = veclib_mix_buffers_no_gain;
 
                         generic_mix_functions = false;
 
@@ -265,12 +274,12 @@ setup_hardware_optimization (bool try_optimization)
         }
 
         if (generic_mix_functions) {
-
-		Session::compute_peak 		= compute_peak;
-		Session::find_peaks 		= find_peaks;
-		Session::apply_gain_to_buffer 	= apply_gain_to_buffer;
-		Session::mix_buffers_with_gain 	= mix_buffers_with_gain;
-		Session::mix_buffers_no_gain 	= mix_buffers_no_gain;
+		
+		compute_peak 		= default_compute_peak;
+		find_peaks 		= default_find_peaks;
+		apply_gain_to_buffer 	= default_apply_gain_to_buffer;
+		mix_buffers_with_gain 	= default_mix_buffers_with_gain;
+		mix_buffers_no_gain 	= default_mix_buffers_no_gain;
 		
 		info << "No H/W specific optimizations in use" << endmsg;
 	}
@@ -298,10 +307,6 @@ ARDOUR::init (bool use_vst, bool try_optimization)
 
 	Profile = new RuntimeProfile;
 
-	if (setup_midi ()) {
-		return -1;
-	}
-    
 #ifdef HAVE_LIBLO
 	if (setup_osc ()) {
 		return -1;
diff --git a/libs/ardour/import.cc b/libs/ardour/import.cc
index 712b9a35e4..7c0deccca1 100644
--- a/libs/ardour/import.cc
+++ b/libs/ardour/import.cc
@@ -34,6 +34,7 @@
 #include <pbd/basename.h>
 
 #include <ardour/ardour.h>
+#include <ardour/types.h>
 #include <ardour/session.h>
 #include <ardour/audio_diskstream.h>
 #include <ardour/sndfilesource.h>
@@ -183,7 +184,8 @@ Session::import_audiofile (import_status& status)
 		} while ( !goodfile);
 
 		try { 
-			newfiles[n] = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, buf, false, frame_rate()));
+			newfiles[n] = boost::dynamic_pointer_cast<AudioFileSource> (
+				SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
 		}
 
 		catch (failed_constructor& err) {
@@ -316,7 +318,6 @@ Session::import_audiofile (import_status& status)
 	}
 
 	if (status.cancel) {
-
 		status.new_regions.clear ();
 
 		for (vector<string>::iterator i = new_paths.begin(); i != new_paths.end(); ++i) {
diff --git a/libs/ardour/insert.cc b/libs/ardour/insert.cc
index ccc73946b5..66cf6b1d4c 100644
--- a/libs/ardour/insert.cc
+++ b/libs/ardour/insert.cc
@@ -29,6 +29,7 @@
 #include <ardour/port.h>
 #include <ardour/route.h>
 #include <ardour/ladspa_plugin.h>
+#include <ardour/buffer_set.h>
 
 #ifdef VST_SUPPORT
 #include <ardour/vst_plugin.h>
@@ -48,6 +49,8 @@ using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
+/* ********** FIXME: TYPE **************
+ * Inserts are still definitely audio only */
 Insert::Insert(Session& s, string name, Placement p)
 	: Redirect (s, name, p)
 {
@@ -77,7 +80,7 @@ PluginInsert::PluginInsert (Session& s, boost::shared_ptr<Plugin> plug, Placemen
 
 	{
 		Glib::Mutex::Lock em (_session.engine().process_lock());
-		IO::MoreOutputs (output_streams ());
+		IO::MoreChannels (max(input_streams(), output_streams()));
 	}
 
 	RedirectCreated (this); /* EMIT SIGNAL */
@@ -96,7 +99,7 @@ PluginInsert::PluginInsert (Session& s, const XMLNode& node)
 
 	{
 		Glib::Mutex::Lock em (_session.engine().process_lock());
-		IO::MoreOutputs (output_streams());
+		IO::MoreChannels (max(input_streams(), output_streams()));
 	}
 }
 
@@ -179,28 +182,32 @@ PluginInsert::auto_state_changed (uint32_t which)
 	}
 }
 
-uint32_t
+ChanCount
 PluginInsert::output_streams() const
 {
-	return _plugins[0]->get_info()->n_outputs * _plugins.size();
+	// FIXME: TYPE
+	return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_outputs * _plugins.size());
 }
 
-uint32_t
+ChanCount
 PluginInsert::input_streams() const
 {
-	return _plugins[0]->get_info()->n_inputs * _plugins.size();
+	// FIXME: TYPE
+	return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_inputs * _plugins.size());
 }
 
-uint32_t
+ChanCount
 PluginInsert::natural_output_streams() const
 {
-	return _plugins[0]->get_info()->n_outputs;
+	// FIXME: TYPE
+	return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_outputs);
 }
 
-uint32_t
+ChanCount
 PluginInsert::natural_input_streams() const
 {
-	return _plugins[0]->get_info()->n_inputs;
+	// FIXME: TYPE
+	return ChanCount(DataType::AUDIO, _plugins[0]->get_info()->n_inputs);
 }
 
 bool
@@ -265,10 +272,10 @@ PluginInsert::deactivate ()
 }
 
 void
-PluginInsert::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now)
+PluginInsert::connect_and_run (BufferSet& bufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now)
 {
-	int32_t in_index = 0;
-	int32_t out_index = 0;
+	uint32_t in_index = 0;
+	uint32_t out_index = 0;
 
 	/* Note that we've already required that plugins
 	   be able to handle in-place processing.
@@ -298,7 +305,7 @@ PluginInsert::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, nframes_t
 	}
 
 	for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
-		(*i)->connect_and_run (bufs, nbufs, in_index, out_index, nframes, offset);
+		(*i)->connect_and_run (bufs, in_index, out_index, nframes, offset);
 	}
 
 	/* leave remaining channel buffers alone */
@@ -339,28 +346,28 @@ PluginInsert::transport_stopped (nframes_t now)
 void
 PluginInsert::silence (nframes_t nframes, nframes_t offset)
 {
-	int32_t in_index = 0;
-	int32_t out_index = 0;
+	uint32_t in_index = 0;
+	uint32_t out_index = 0;
 
 	uint32_t n;
 
 	if (active()) {
 		for (vector<boost::shared_ptr<Plugin> >::iterator i = _plugins.begin(); i != _plugins.end(); ++i) {
 			n = (*i) -> get_info()->n_inputs;
-			(*i)->connect_and_run (_session.get_silent_buffers (n), n, in_index, out_index, nframes, offset);
+			(*i)->connect_and_run (_session.get_silent_buffers (ChanCount(DataType::AUDIO, n)), in_index, out_index, nframes, offset);
 		}
 	}
 }
 	
 void
-PluginInsert::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
+PluginInsert::run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
 {
 	if (active()) {
 
 		if (_session.transport_rolling()) {
-			automation_run (bufs, nbufs, nframes, offset);
+			automation_run (bufs, nframes, offset);
 		} else {
-			connect_and_run (bufs, nbufs, nframes, offset, false);
+			connect_and_run (bufs, nframes, offset, false);
 		}
 	} else {
 		uint32_t in = _plugins[0]->get_info()->n_inputs;
@@ -371,9 +378,11 @@ PluginInsert::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nf
 			/* not active, but something has make up for any channel count increase */
 			
 			for (uint32_t n = out - in; n < out; ++n) {
-				memcpy (bufs[n], bufs[in - 1], sizeof (Sample) * nframes);
+				memcpy (bufs.get_audio(n).data(nframes, offset), bufs.get_audio(in - 1).data(nframes, offset), sizeof (Sample) * nframes);
 			}
 		}
+
+		bufs.count().set(DataType::AUDIO, out);
 	}
 }
 
@@ -392,7 +401,7 @@ PluginInsert::set_parameter (uint32_t port, float val)
 }
 
 void
-PluginInsert::automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
+PluginInsert::automation_run (BufferSet& bufs, nframes_t nframes, nframes_t offset)
 {
 	ControlEvent next_event (0, 0.0f);
 	nframes_t now = _session.transport_frame ();
@@ -401,7 +410,7 @@ PluginInsert::automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t
 	Glib::Mutex::Lock lm (_automation_lock, Glib::TRY_LOCK);
 
 	if (!lm.locked()) {
-		connect_and_run (bufs, nbufs, nframes, offset, false);
+		connect_and_run (bufs, nframes, offset, false);
 		return;
 	}
 	
@@ -409,7 +418,7 @@ PluginInsert::automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t
 		
  		/* no events have a time within the relevant range */
 		
- 		connect_and_run (bufs, nbufs, nframes, offset, true, now);
+ 		connect_and_run (bufs, nframes, offset, true, now);
  		return;
  	}
 	
@@ -417,7 +426,7 @@ PluginInsert::automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t
 
 		nframes_t cnt = min (((nframes_t) ceil (next_event.when) - now), nframes);
   
- 		connect_and_run (bufs, nbufs, cnt, offset, true, now);
+ 		connect_and_run (bufs, cnt, offset, true, now);
  		
  		nframes -= cnt;
  		offset += cnt;
@@ -431,7 +440,7 @@ PluginInsert::automation_run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t
  	/* cleanup anything that is left to do */
   
  	if (nframes) {
- 		connect_and_run (bufs, nbufs, nframes, offset, true, now);
+ 		connect_and_run (bufs, nframes, offset, true, now);
   	}
 }	
 
@@ -789,7 +798,7 @@ PluginInsert::describe_parameter (uint32_t what)
 	return _plugins[0]->describe_parameter (what);
 }
 
-nframes_t 
+ARDOUR::nframes_t 
 PluginInsert::latency() 
 {
 	return _plugins[0]->latency ();
@@ -833,7 +842,6 @@ PortInsert::PortInsert (Session& s, Placement p)
 {
 	init ();
 	RedirectCreated (this); /* EMIT SIGNAL */
-
 }
 
 PortInsert::PortInsert (const PortInsert& other)
@@ -873,9 +881,9 @@ PortInsert::~PortInsert ()
 }
 
 void
-PortInsert::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
+PortInsert::run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
 {
-	if (n_outputs() == 0) {
+	if (n_outputs().get(_default_type) == 0) {
 		return;
 	}
 
@@ -885,22 +893,9 @@ PortInsert::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nfra
 		return;
 	}
 
-	uint32_t n;
-	vector<Port*>::iterator o;
-	vector<Port*>::iterator i;
+	deliver_output(bufs, start_frame, end_frame, nframes, offset);
 
-	/* deliver output */
-
-	for (o = _outputs.begin(), n = 0; o != _outputs.end(); ++o, ++n) {
-		memcpy ((*o)->get_buffer (nframes) + offset, bufs[min(nbufs,n)], sizeof (Sample) * nframes);
-		(*o)->mark_silence (false);
-	}
-	
-	/* collect input */
-	
-	for (i = _inputs.begin(), n = 0; i != _inputs.end(); ++i, ++n) {
-		memcpy (bufs[min(nbufs,n)], (*i)->get_buffer (nframes) + offset, sizeof (Sample) * nframes);
-	}
+	collect_input(bufs, nframes, offset);
 }
 
 XMLNode&
@@ -962,7 +957,7 @@ PortInsert::set_state(const XMLNode& node)
 	return 0;
 }
 
-nframes_t 
+ARDOUR::nframes_t 
 PortInsert::latency() 
 {
 	/* because we deliver and collect within the same cycle,
@@ -978,7 +973,7 @@ PortInsert::latency()
 int32_t
 PortInsert::can_support_input_configuration (int32_t in) const
 {
-	if (input_maximum() == -1 && output_maximum() == -1) {
+	if (input_maximum() == ChanCount::INFINITE && output_maximum() == ChanCount::INFINITE) {
 
 		/* not configured yet */
 
@@ -990,7 +985,7 @@ PortInsert::can_support_input_configuration (int32_t in) const
 		   many output ports it will have.
 		*/
 
-		if (output_maximum() == in) {
+		if (output_maximum().get(_default_type) == static_cast<uint32_t>(in)) {
 			return 1;
 		} 
 	}
@@ -1015,36 +1010,36 @@ PortInsert::configure_io (int32_t ignored_magic, int32_t in, int32_t out)
 	   to the number of input ports we need.
 	*/
 
-	set_output_maximum (in);
-	set_output_minimum (in);
-	set_input_maximum (out);
-	set_input_minimum (out);
+	set_output_maximum (ChanCount(_default_type, in));
+	set_output_minimum (ChanCount(_default_type, in));
+	set_input_maximum (ChanCount(_default_type, out));
+	set_input_minimum (ChanCount(_default_type, out));
 
 	if (in < 0) {
-		in = n_outputs ();
+		in = n_outputs ().get(_default_type);
 	} 
 
 	if (out < 0) {
-		out = n_inputs ();
+		out = n_inputs ().get(_default_type);
 	}
 
-	return ensure_io (out, in, false, this);
+	return ensure_io (ChanCount(_default_type, out), ChanCount(_default_type, in), false, this);
 }
 
 int32_t
 PortInsert::compute_output_streams (int32_t cnt) const
 {
 	/* puzzling, eh? think about it ... */
-	return n_inputs ();
+	return n_inputs ().get(_default_type);
 }
 
-uint32_t
+ChanCount
 PortInsert::output_streams() const
 {
 	return n_inputs ();
 }
 
-uint32_t
+ChanCount
 PortInsert::input_streams() const
 {
 	return n_outputs ();
diff --git a/libs/ardour/io.cc b/libs/ardour/io.cc
index 0bda946d11..184077b5f1 100644
--- a/libs/ardour/io.cc
+++ b/libs/ardour/io.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000 Paul Davis 
+    Copyright (C) 2000-2006 Paul Davis 
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -14,7 +14,6 @@
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
 */
 
 #include <fstream>
@@ -33,11 +32,15 @@
 #include <ardour/audioengine.h>
 #include <ardour/io.h>
 #include <ardour/port.h>
+#include <ardour/audio_port.h>
+#include <ardour/midi_port.h>
 #include <ardour/connection.h>
 #include <ardour/session.h>
 #include <ardour/cycle_timer.h>
 #include <ardour/panner.h>
-#include <ardour/dB.h>
+#include <ardour/buffer_set.h>
+#include <ardour/meter.h>
+#include <ardour/amp.h>
 
 #include "i18n.h"
 
@@ -60,18 +63,19 @@ using namespace ARDOUR;
 using namespace PBD;
 
 nframes_t    IO::_automation_interval = 0;
-const string IO::state_node_name = "IO";
-bool         IO::connecting_legal = false;
-bool         IO::ports_legal = false;
-bool         IO::panners_legal = false;
-sigc::signal<void>                IO::Meter;
-sigc::signal<int>                 IO::ConnectingLegal;
-sigc::signal<int>                 IO::PortsLegal;
-sigc::signal<int>                 IO::PannersLegal;
-sigc::signal<void,uint32_t>  IO::MoreOutputs;
-sigc::signal<int>                 IO::PortsCreated;
-
-Glib::StaticMutex       IO::m_meter_signal_lock = GLIBMM_STATIC_MUTEX_INIT;
+
+const string                 IO::state_node_name = "IO";
+bool                         IO::connecting_legal = false;
+bool                         IO::ports_legal = false;
+bool                         IO::panners_legal = false;
+sigc::signal<void>           IO::Meter;
+sigc::signal<int>            IO::ConnectingLegal;
+sigc::signal<int>            IO::PortsLegal;
+sigc::signal<int>            IO::PannersLegal;
+sigc::signal<void,ChanCount> IO::MoreChannels;
+sigc::signal<int>            IO::PortsCreated;
+
+Glib::StaticMutex IO::m_meter_signal_lock = GLIBMM_STATIC_MUTEX_INIT;
 
 /* this is a default mapper of [0 .. 1.0] control values to a gain coefficient.
    others can be imagined. 
@@ -90,11 +94,6 @@ static double direct_gain_to_control (gain_t gain) {
 	return pow((6.0*log(gain)/log(2.0)+192.0)/198.0, 8.0);
 }
 
-static bool sort_ports_by_name (Port* a, Port* b)
-{
-	return a->name() < b->name();
-}
-
 
 /** @param default_type The type of port that will be created by ensure_io
  * and friends if no type is explicitly requested (to avoid breakage).
@@ -103,28 +102,42 @@ IO::IO (Session& s, string name,
 	int input_min, int input_max, int output_min, int output_max,
 	DataType default_type)
 	: _session (s),
+      _output_buffers(new BufferSet()),
 	  _name (name),
 	  _default_type(default_type),
 	  _gain_control (X_("gaincontrol"), *this),
 	  _gain_automation_curve (0.0, 2.0, 1.0),
-	  _input_minimum (input_min),
-	  _input_maximum (input_max),
-	  _output_minimum (output_min),
-	  _output_maximum (output_max)
+	  _input_minimum (ChanCount::ZERO),
+	  _input_maximum (ChanCount::INFINITE),
+	  _output_minimum (ChanCount::ZERO),
+	  _output_maximum (ChanCount::INFINITE)
 {
 	_panner = new Panner (name, _session);
+	_meter = new PeakMeter (_session);
+
+	if (input_min > 0) {
+		_input_minimum = ChanCount(_default_type, input_min);
+	}
+	if (input_max >= 0) {
+		_input_maximum = ChanCount(_default_type, input_max);
+	}
+	if (output_min > 0) {
+		_output_minimum = ChanCount(_default_type, output_min);
+	}
+	if (output_max >= 0) {
+		_output_maximum = ChanCount(_default_type, output_max);
+	}
+
 	_gain = 1.0;
 	_desired_gain = 1.0;
 	_input_connection = 0;
 	_output_connection = 0;
 	pending_state_node = 0;
-	_ninputs = 0;
-	_noutputs = 0;
 	no_panner_reset = false;
+	_phase_invert = false;
 	deferred_state = 0;
 
 	apply_gain_automation = false;
-	_ignore_gain_on_deliver = false;
 	
 	last_automation_snapshot = 0;
 
@@ -137,16 +150,23 @@ IO::IO (Session& s, string name,
 		Glib::Mutex::Lock guard (m_meter_signal_lock);
 		m_meter_connection = Meter.connect (mem_fun (*this, &IO::meter));
 	}
+	
+	// Connect to our own MoreChannels signal to connect output buffers
+	IO::MoreChannels.connect (mem_fun (*this, &IO::attach_buffers));
 
 	_session.add_controllable (&_gain_control);
 }
 
 IO::IO (Session& s, const XMLNode& node, DataType dt)
 	: _session (s),
+      _output_buffers(new BufferSet()),
 	  _default_type (dt),
 	  _gain_control (X_("gaincontrol"), *this),
 	  _gain_automation_curve (0, 0, 0) // all reset in set_state()
 {
+	// FIXME: hack
+	_meter = new PeakMeter (_session);
+
 	_panner = 0;
 	deferred_state = 0;
 	no_panner_reset = false;
@@ -154,11 +174,8 @@ IO::IO (Session& s, const XMLNode& node, DataType dt)
 	_gain = 1.0;
 	_input_connection = 0;
 	_output_connection = 0;
-	_ninputs = 0;
-	_noutputs = 0;
 
 	apply_gain_automation = false;
-	_ignore_gain_on_deliver = false;
 
 	set_state (node);
 
@@ -168,6 +185,9 @@ IO::IO (Session& s, const XMLNode& node, DataType dt)
 		Glib::Mutex::Lock guard (m_meter_signal_lock);
 		m_meter_connection = Meter.connect (mem_fun (*this, &IO::meter));
 	}
+	
+	// Connect to our own MoreChannels signal to connect output buffers
+	IO::MoreChannels.connect (mem_fun (*this, &IO::attach_buffers));
 
 	_session.add_controllable (&_gain_control);
 }
@@ -177,17 +197,20 @@ IO::~IO ()
 	Glib::Mutex::Lock guard (m_meter_signal_lock);
 	
 	Glib::Mutex::Lock lm (io_lock);
-	vector<Port *>::iterator i;
 
-	for (i = _inputs.begin(); i != _inputs.end(); ++i) {
+	for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 		_session.engine().unregister_port (*i);
 	}
 
-	for (i = _outputs.begin(); i != _outputs.end(); ++i) {
+	for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 		_session.engine().unregister_port (*i);
 	}
 
 	m_meter_connection.disconnect();
+
+	delete _meter;
+	delete _panner;
+	delete _output_buffers;
 }
 
 void
@@ -195,384 +218,102 @@ IO::silence (nframes_t nframes, nframes_t offset)
 {
 	/* io_lock, not taken: function must be called from Session::process() calltree */
 
-	for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
-		(*i)->silence (nframes, offset);
+	for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+		i->get_buffer().silence (nframes, offset);
 	}
 }
 
+/** Deliver bufs to the IO's Jack outputs.
+ *
+ * This function should automatically do whatever it necessary to correctly deliver bufs
+ * to the outputs, eg applying gain or pan or whatever else needs to be done.
+ */
 void
-IO::apply_declick (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, gain_t initial, gain_t target, bool invert_polarity)
+IO::deliver_output (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
 {
-	nframes_t declick = min ((nframes_t)128, nframes);
-	gain_t delta;
-	Sample *buffer;
-	double fractional_shift;
-	double fractional_pos;
-	gain_t polscale = invert_polarity ? -1.0f : 1.0f;
+	// FIXME: type specific code doesn't actually need to be here, it will go away in time
 
-	if (nframes == 0) return;
-	
-	fractional_shift = -1.0/declick;
+	/* ********** AUDIO ********** */
 
-	if (target < initial) {
-		/* fade out: remove more and more of delta from initial */
-		delta = -(initial - target);
-	} else {
-		/* fade in: add more and more of delta from initial */
-		delta = target - initial;
-	}
-
-	for (uint32_t n = 0; n < nbufs; ++n) {
-
-		buffer = bufs[n];
-		fractional_pos = 1.0;
-
-		for (nframes_t nx = 0; nx < declick; ++nx) {
-			buffer[nx] *= polscale * (initial + (delta * (0.5 + 0.5 * cos (M_PI * fractional_pos))));
-			fractional_pos += fractional_shift;
-		}
+	// Apply gain if gain automation isn't playing
+	if ( ! apply_gain_automation) {
 		
-		/* now ensure the rest of the buffer has the target value
-		   applied, if necessary.
-		*/
-
-		if (declick != nframes) {
-			float this_target;
-
-			if (invert_polarity) {
-				this_target = -target;
-			} else { 
-				this_target = target;
-			}
-
-			if (this_target == 0.0) {
-				memset (&buffer[declick], 0, sizeof (Sample) * (nframes - declick));
-			} else if (this_target != 1.0) {
-				for (nframes_t nx = declick; nx < nframes; ++nx) {
-					buffer[nx] *= this_target;
-				}
-			}
-		}
-	}
-}
-
-void
-IO::pan_automated (vector<Sample*>& bufs, uint32_t nbufs, nframes_t start, nframes_t end, nframes_t nframes, nframes_t offset)
-{
-	Sample* dst;
-
-	/* io_lock, not taken: function must be called from Session::process() calltree */
-
-	if (_noutputs == 0) {
-		return;
-	}
-
-	if (_noutputs == 1) {
-
-		dst = output(0)->get_buffer (nframes) + offset;
-
-		for (uint32_t n = 0; n < nbufs; ++n) {
-			if (bufs[n] != dst) {
-				memcpy (dst, bufs[n], sizeof (Sample) * nframes);
-			} 
-		}
-
-		output(0)->mark_silence (false);
-
-		return;
-	}
-
-	uint32_t o;
-	vector<Port *>::iterator out;
-	vector<Sample *>::iterator in;
-	Panner::iterator pan;
-	Sample* obufs[_noutputs];
-
-	/* the terrible silence ... */
-
-	for (out = _outputs.begin(), o = 0; out != _outputs.end(); ++out, ++o) {
-		obufs[o] = (*out)->get_buffer (nframes) + offset;
-		memset (obufs[o], 0, sizeof (Sample) * nframes);
-		(*out)->mark_silence (false);
-	}
-
-	uint32_t n;
-
-	for (pan = _panner->begin(), n = 0; n < nbufs; ++n, ++pan) {
-		(*pan)->distribute_automated (bufs[n], obufs, start, end, nframes, _session.pan_automation_buffer());
-	}
-}
-
-void
-IO::pan (vector<Sample*>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset, gain_t gain_coeff)
-{
-	Sample* dst;
-	Sample* src;
-
-	/* io_lock, not taken: function must be called from Session::process() calltree */
-
-	if (_noutputs == 0) {
-		return;
-	}
-
-	/* the panner can be empty if there are no inputs to the 
-	   route, but still outputs
-	*/
-
-	if (_panner->bypassed() || _panner->empty()) {
-		deliver_output_no_pan (bufs, nbufs, nframes, offset);
-		return;
-	}
-
-	if (_noutputs == 1) {
-
-		dst = output(0)->get_buffer (nframes) + offset;
-
-		if (gain_coeff == 0.0f) {
-
-			/* only one output, and gain was zero, so make it silent */
-
-			memset (dst, 0, sizeof (Sample) * nframes); 
-			
-		} else if (gain_coeff == 1.0f){
-
-			/* mix all buffers into the output */
-
-			uint32_t n;
-			
-			memcpy (dst, bufs[0], sizeof (Sample) * nframes);
-			
-			for (n = 1; n < nbufs; ++n) {
-				Session::mix_buffers_no_gain(dst,bufs[n],nframes);
-			}
-
-			output(0)->mark_silence (false);
-
-		} else {
-
-			/* mix all buffers into the output, scaling them all by the gain */
+		gain_t dg = _gain; // desired gain
 
-			uint32_t n;
-
-			src = bufs[0];
-			
-			for (nframes_t n = 0; n < nframes; ++n) {
-				dst[n] = src[n] * gain_coeff;
-			}	
+		{
+			Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
 
-			for (n = 1; n < nbufs; ++n) {
-				Session::mix_buffers_with_gain(dst,bufs[n],nframes,gain_coeff);
+			if (dm.locked()) {
+				dg = _desired_gain;
 			}
-			
-			output(0)->mark_silence (false);
-		}
 
-		return;
-	}
-
-	uint32_t o;
-	vector<Port *>::iterator out;
-	vector<Sample *>::iterator in;
-	Panner::iterator pan;
-	Sample* obufs[_noutputs];
-
-	/* the terrible silence ... */
-
-	/* XXX this is wasteful but i see no way to avoid it */
-	
-	for (out = _outputs.begin(), o = 0; out != _outputs.end(); ++out, ++o) {
-		obufs[o] = (*out)->get_buffer (nframes) + offset;
-		memset (obufs[o], 0, sizeof (Sample) * nframes);
-		(*out)->mark_silence (false);
-	}
-
-	uint32_t n;
-
-	for (pan = _panner->begin(), n = 0; n < nbufs; ++n) {
-		Panner::iterator tmp;
-
-		tmp = pan;
-		++tmp;
-
-		(*pan)->distribute (bufs[n], obufs, gain_coeff, nframes);
-
-		if (tmp != _panner->end()) {
-			pan = tmp;
 		}
-	}
-}
 
-void
-IO::deliver_output (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
-{
-	/* io_lock, not taken: function must be called from Session::process() calltree */
-
-	if (_noutputs == 0) {
-		return;
-	}
-	
-	if (_panner->bypassed() || _panner->empty()) {
-		deliver_output_no_pan (bufs, nbufs, nframes, offset);
-		return;
+		if (dg != _gain || dg != 1.0)
+			Amp::run(bufs, nframes, _gain, dg, _phase_invert);
 	}
-
-
-	gain_t dg;
-	gain_t pangain = _gain;
 	
-	{
-		Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
-		
-		if (dm.locked()) {
-			dg = _desired_gain;
-		} else {
-			dg = _gain;
-		}
-	}
-
-	if (dg != _gain) {
-		apply_declick (bufs, nbufs, nframes, _gain, dg, false);
-		_gain = dg;
-		pangain = 1.0f;
-	} 
-
-	/* simple, non-automation panning to outputs */
-
-	if (_session.transport_speed() > 1.5f || _session.transport_speed() < -1.5f) {
-		pan (bufs, nbufs, nframes, offset, pangain * speed_quietning);
+	// Use the panner to distribute audio to output port buffers
+	if (_panner && !_panner->empty() && !_panner->bypassed()) {
+		_panner->distribute (bufs, output_buffers(), start_frame, end_frame, nframes, offset);
 	} else {
-		pan (bufs, nbufs, nframes, offset, pangain);
-	}
-}
-
-void
-IO::deliver_output_no_pan (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
-{
-	/* io_lock, not taken: function must be called from Session::process() calltree */
-
-	if (_noutputs == 0) {
-		return;
-	}
-
-	gain_t dg;
-	gain_t old_gain = _gain;
-
-	if (apply_gain_automation || _ignore_gain_on_deliver) {
-
-		/* gain has already been applied by automation code. do nothing here except
-		   speed quietning.
-		*/
-
-		_gain = 1.0f;
-		dg = _gain;
+		const DataType type = DataType::AUDIO;
 		
-	} else {
-
-		Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
+		// Copy any audio 1:1 to outputs
 		
-		if (dm.locked()) {
-			dg = _desired_gain;
-		} else {
-			dg = _gain;
+		BufferSet::iterator o = output_buffers().begin(type);
+		BufferSet::iterator i = bufs.begin(type);
+		BufferSet::iterator prev = i;
+		
+		while (i != bufs.end(type) && o != output_buffers().end (type)) {
+			o->read_from(*i, nframes, offset);
+			prev = i;
+			++i;
+			++o;
 		}
-	}
 
-	Sample* src;
-	Sample* dst;
-	uint32_t i;
-	vector<Port*>::iterator o;
-	vector<Sample*> outs;
-	gain_t actual_gain;
+		/* extra outputs get a copy of the last buffer */
 
-	if (dg != _gain) {
-		/* unlikely condition */
-		for (o = _outputs.begin(), i = 0; o != _outputs.end(); ++o, ++i) {
-			outs.push_back ((*o)->get_buffer (nframes) + offset);
+		while (o != output_buffers().end(type)) {
+			o->read_from(*prev, nframes, offset);
+			++o;
 		}
 	}
 
-	/* reduce nbufs to the index of the last input buffer */
+	/* ********** MIDI ********** */
 
-	nbufs--;
-
-	if (_session.transport_speed() > 1.5f || _session.transport_speed() < -1.5f) {
-		actual_gain = _gain * speed_quietning;
-	} else {
-		actual_gain = _gain;
-	}
-	
-	for (o = _outputs.begin(), i = 0; o != _outputs.end(); ++o, ++i) {
-
-		dst = (*o)->get_buffer (nframes) + offset;
-		src = bufs[min(nbufs,i)];
-
-		if (dg != _gain || actual_gain == 1.0f) {
-			memcpy (dst, src, sizeof (Sample) * nframes);
-		} else if (actual_gain == 0.0f) {
-			memset (dst, 0, sizeof (Sample) * nframes);
-		} else {
-			for (nframes_t x = 0; x < nframes; ++x) {
-				dst[x] = src[x] * actual_gain;
-			}
-		}
-		
-		(*o)->mark_silence (false);
+	// No MIDI, we're done here
+	if (bufs.count().get(DataType::MIDI) == 0) {
+		return;
 	}
 
-	if (dg != _gain) {
-		apply_declick (outs, outs.size(), nframes, _gain, dg, false);
-		_gain = dg;
-	}
+	const DataType type = DataType::MIDI;
 
-	if (apply_gain_automation || _ignore_gain_on_deliver) {
-		_gain = old_gain;
+	// Copy any MIDI 1:1 to outputs
+	assert(bufs.count().get(DataType::MIDI) == output_buffers().count().get(DataType::MIDI));
+	BufferSet::iterator o = output_buffers().begin(type);
+	for (BufferSet::iterator i = bufs.begin(type); i != bufs.end(type); ++i, ++o) {
+		o->read_from(*i, nframes, offset);
 	}
 }
 
 void
-IO::collect_input (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
+IO::collect_input (BufferSet& outs, nframes_t nframes, nframes_t offset)
 {
-	/* io_lock, not taken: function must be called from Session::process() calltree */
+	assert(outs.available() >= n_inputs());
 
-	vector<Port *>::iterator i;
-	uint32_t n;
-	Sample *last = 0;
+	outs.set_count(n_inputs());
 	
-	/* we require that bufs.size() >= 1 */
+	if (outs.count() == ChanCount::ZERO)
+		return;
 
-	for (n = 0, i = _inputs.begin(); n < nbufs; ++i, ++n) {
-		if (i == _inputs.end()) {
-			break;
-		}
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 		
-		/* XXX always read the full extent of the port buffer that
-		   we need. One day, we may use jack_port_get_buffer_at_offset()
-		   or something similar. For now, this simple hack will
-		   have to do.
-
-		   Hack? Why yes .. we only need to read nframes-worth of
-		   data, but the data we want is at `offset' within the
-		   buffer.
-		*/
-
-		last = (*i)->get_buffer (nframes+offset) + offset;
-		// the dest buffer's offset has already been applied
-		memcpy (bufs[n], last, sizeof (Sample) * nframes);
-	}
-
-	/* fill any excess outputs with the last input */
-	
-	if (last) {
-		while (n < nbufs) {
-			// the dest buffer's offset has already been applied
-			memcpy (bufs[n], last, sizeof (Sample) * nframes);
-			++n;
-		}
-	} else {
-		while (n < nbufs) {
-			memset (bufs[n], 0, sizeof (Sample) * nframes);
-			++n;
+		BufferSet::iterator o = outs.begin(*t);
+		for (PortSet::iterator i = _inputs.begin(*t); i != _inputs.end(*t); ++i, ++o) {
+			o->read_from(i->get_buffer(), nframes, offset);
 		}
+
 	}
 }
 
@@ -580,14 +321,11 @@ void
 IO::just_meter_input (nframes_t start_frame, nframes_t end_frame, 
 		      nframes_t nframes, nframes_t offset)
 {
-	vector<Sample*>& bufs = _session.get_passthru_buffers ();
-	uint32_t nbufs = n_process_buffers ();
+	BufferSet& bufs = _session.get_scratch_buffers (n_inputs());
 
-	collect_input (bufs, nbufs, nframes, offset);
+	collect_input (bufs, nframes, offset);
 
-	for (uint32_t n = 0; n < nbufs; ++n) {
-		_peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
-	}
+	_meter->run(bufs, nframes);
 }
 
 void
@@ -623,7 +361,7 @@ IO::disconnect_input (Port* our_port, string other_port, void* src)
 			
 			/* check that our_port is really one of ours */
 			
-			if (find (_inputs.begin(), _inputs.end(), our_port) == _inputs.end()) {
+			if ( ! _inputs.contains(our_port)) {
 				return -1;
 			}
 			
@@ -659,7 +397,7 @@ IO::connect_input (Port* our_port, string other_port, void* src)
 			
 			/* check that our_port is really one of ours */
 			
-			if (find (_inputs.begin(), _inputs.end(), our_port) == _inputs.end()) {
+			if ( ! _inputs.contains(our_port) ) {
 				return -1;
 			}
 			
@@ -691,7 +429,9 @@ IO::disconnect_output (Port* our_port, string other_port, void* src)
 		{
 			Glib::Mutex::Lock lm (io_lock);
 			
-			if (find (_outputs.begin(), _outputs.end(), our_port) == _outputs.end()) {
+			/* check that our_port is really one of ours */
+			
+			if ( ! _outputs.contains(our_port) ) {
 				return -1;
 			}
 			
@@ -727,7 +467,7 @@ IO::connect_output (Port* our_port, string other_port, void* src)
 			
 			/* check that our_port is really one of ours */
 			
-			if (find (_outputs.begin(), _outputs.end(), our_port) == _outputs.end()) {
+			if ( ! _outputs.contains(our_port) ) {
 				return -1;
 			}
 			
@@ -753,24 +493,24 @@ IO::set_input (Port* other_port, void* src)
 	   to the specified source.
 	*/
 
-	if (_input_minimum > 1 || _input_minimum == 0) {
+	if (_input_minimum.get_total() > 1) {
 		/* sorry, you can't do this */
 		return -1;
 	}
 
 	if (other_port == 0) {
-		if (_input_minimum < 0) {
-			return ensure_inputs (0, false, true, src);
+		if (_input_minimum == ChanCount::ZERO) {
+			return ensure_inputs (ChanCount::ZERO, false, true, src);
 		} else {
 			return -1;
 		}
 	}
 
-	if (ensure_inputs (1, true, true, src)) {
+	if (ensure_inputs (ChanCount(other_port->type(), 1), true, true, src)) {
 		return -1;
 	}
 
-	return connect_input (_inputs.front(), other_port->name(), src);
+	return connect_input (_inputs.port(0), other_port->name(), src);
 }
 
 int
@@ -784,41 +524,34 @@ IO::remove_output_port (Port* port, void* src)
 		
 		{
 			Glib::Mutex::Lock lm (io_lock);
-			
-			if (_noutputs - 1 == (uint32_t) _output_minimum) {
+
+			if (n_outputs() <= _output_minimum) {
 				/* sorry, you can't do this */
 				return -1;
 			}
-			
-			for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
-				if (*i == port) {
-					change = IOChange (change|ConfigurationChanged);
-					if (port->connected()) {
-						change = IOChange (change|ConnectionsChanged);
-					} 
-
-					_session.engine().unregister_port (*i);
-					_outputs.erase (i);
-					_noutputs--;
-					drop_output_connection ();
-
-					break;
-				}
-			}
 
-			if (change != NoChange) {
+			if (_outputs.remove(port)) {
+				change = IOChange (change|ConfigurationChanged);
+
+				if (port->connected()) {
+					change = IOChange (change|ConnectionsChanged);
+				} 
+
+				_session.engine().unregister_port (*port);
+				drop_output_connection ();
+				
 				setup_peak_meters ();
 				reset_panner ();
 			}
 		}
 	}
-	
+
 	if (change != NoChange) {
-		output_changed (change, src); /* EMIT SIGNAL */
+		output_changed (change, src);
 		_session.set_dirty ();
 		return 0;
-	}
-
+	} 
+	
 	return -1;
 }
 
@@ -844,14 +577,14 @@ IO::add_output_port (string destination, void* src, DataType type)
 		{ 
 			Glib::Mutex::Lock lm (io_lock);
 			
-			if (_output_maximum >= 0 && (int) _noutputs == _output_maximum) {
+			if (n_outputs() >= _output_maximum) {
 				return -1;
 			}
 		
 			/* Create a new output port */
 			
 			// FIXME: naming scheme for differently typed ports?
-			if (_output_maximum == 1) {
+			if (_output_maximum.get(type) == 1) {
 				snprintf (name, sizeof (name), _("%s/out"), _name.c_str());
 			} else {
 				snprintf (name, sizeof (name), _("%s/out %u"), _name.c_str(), find_output_port_hole());
@@ -862,15 +595,13 @@ IO::add_output_port (string destination, void* src, DataType type)
 				return -1;
 			}
 			
-			_outputs.push_back (our_port);
-			sort (_outputs.begin(), _outputs.end(), sort_ports_by_name);
-			++_noutputs;
+			_outputs.add (our_port);
 			drop_output_connection ();
 			setup_peak_meters ();
 			reset_panner ();
 		}
 
-		MoreOutputs (_noutputs); /* EMIT SIGNAL */
+		MoreChannels (n_outputs()); /* EMIT SIGNAL */
 	}
 
 	if (destination.length()) {
@@ -882,6 +613,7 @@ IO::add_output_port (string destination, void* src, DataType type)
 	// pan_changed (src); /* EMIT SIGNAL */
 	output_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 	_session.set_dirty ();
+	
 	return 0;
 }
 
@@ -897,29 +629,21 @@ IO::remove_input_port (Port* port, void* src)
 		{
 			Glib::Mutex::Lock lm (io_lock);
 
-			if (((int)_ninputs - 1) < _input_minimum) {
+			if (n_inputs() <= _input_minimum) {
 				/* sorry, you can't do this */
 				return -1;
 			}
-			for (vector<Port *>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
-
-				if (*i == port) {
-					change = IOChange (change|ConfigurationChanged);
 
-					if (port->connected()) {
-						change = IOChange (change|ConnectionsChanged);
-					} 
+			if (_inputs.remove(port)) {
+				change = IOChange (change|ConfigurationChanged);
 
-					_session.engine().unregister_port (*i);
-					_inputs.erase (i);
-					_ninputs--;
-					drop_input_connection ();
+				if (port->connected()) {
+					change = IOChange (change|ConnectionsChanged);
+				} 
 
-					break;
-				}
-			}
-			
-			if (change != NoChange) {
+				_session.engine().unregister_port (*port);
+				drop_input_connection ();
+				
 				setup_peak_meters ();
 				reset_panner ();
 			}
@@ -931,7 +655,7 @@ IO::remove_input_port (Port* port, void* src)
 		_session.set_dirty ();
 		return 0;
 	} 
-
+	
 	return -1;
 }
 
@@ -957,14 +681,14 @@ IO::add_input_port (string source, void* src, DataType type)
 		{ 
 			Glib::Mutex::Lock lm (io_lock);
 			
-			if (_input_maximum >= 0 && (int) _ninputs == _input_maximum) {
+			if (n_inputs() >= _input_maximum) {
 				return -1;
 			}
 
 			/* Create a new input port */
 			
 			// FIXME: naming scheme for differently typed ports?
-			if (_input_maximum == 1) {
+			if (_input_maximum.get(type) == 1) {
 				snprintf (name, sizeof (name), _("%s/in"), _name.c_str());
 			} else {
 				snprintf (name, sizeof (name), _("%s/in %u"), _name.c_str(), find_input_port_hole());
@@ -974,16 +698,14 @@ IO::add_input_port (string source, void* src, DataType type)
 				error << string_compose(_("IO: cannot register input port %1"), name) << endmsg;
 				return -1;
 			}
-			
-			_inputs.push_back (our_port);
-			sort (_inputs.begin(), _inputs.end(), sort_ports_by_name);
-			++_ninputs;
+
+			_inputs.add (our_port);
 			drop_input_connection ();
 			setup_peak_meters ();
 			reset_panner ();
 		}
 
-		MoreOutputs (_ninputs); /* EMIT SIGNAL */
+		MoreChannels (n_inputs()); /* EMIT SIGNAL */
 	}
 
 	if (source.length()) {
@@ -996,7 +718,7 @@ IO::add_input_port (string source, void* src, DataType type)
 	// pan_changed (src); /* EMIT SIGNAL */
 	input_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 	_session.set_dirty ();
-
+	
 	return 0;
 }
 
@@ -1009,14 +731,16 @@ IO::disconnect_inputs (void* src)
 		{
 			Glib::Mutex::Lock lm (io_lock);
 			
-			for (vector<Port *>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+			for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 				_session.engine().disconnect (*i);
 			}
 
 			drop_input_connection ();
 		}
 	}
+	
 	input_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
+	
 	return 0;
 }
 
@@ -1029,7 +753,7 @@ IO::disconnect_outputs (void* src)
 		{
 			Glib::Mutex::Lock lm (io_lock);
 			
-			for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+			for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 				_session.engine().disconnect (*i);
 			}
 
@@ -1039,74 +763,74 @@ IO::disconnect_outputs (void* src)
 
 	output_changed (ConnectionsChanged, src); /* EMIT SIGNAL */
 	_session.set_dirty ();
+	
 	return 0;
 }
 
 bool
-IO::ensure_inputs_locked (uint32_t n, bool clear, void* src)
+IO::ensure_inputs_locked (ChanCount count, bool clear, void* src)
 {
-	Port* input_port;
-	bool changed = false;
-	bool reduced = false;
-	
-	/* remove unused ports */
+	Port* input_port = 0;
+	bool  changed    = false;
 
-	while (_ninputs > n) {
-		_session.engine().unregister_port (_inputs.back());
-		_inputs.pop_back();
-		_ninputs--;
-		reduced = true;
-		changed = true;
-	}
-		
-	/* create any necessary new ports */
-		
-	while (_ninputs < n) {
-		
-		char buf[64];
-		
-		/* Create a new input port (of the default type) */
+
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 		
-		if (_input_maximum == 1) {
-			snprintf (buf, sizeof (buf), _("%s/in"), _name.c_str());
-		}
-		else {
-			snprintf (buf, sizeof (buf), _("%s/in %u"), _name.c_str(), find_input_port_hole());
+		const size_t n = count.get(*t);
+	
+		/* remove unused ports */
+		for (size_t i = n_inputs().get(*t); i > n; --i) {
+			input_port = _inputs.port(*t, i-1);
+
+			assert(input_port);
+			_inputs.remove(input_port);
+			_session.engine().unregister_port (*input_port);
+
+			changed = true;
 		}
-		
-		try {
-			
-			if ((input_port = _session.engine().register_input_port (_default_type, buf)) == 0) {
-				error << string_compose(_("IO: cannot register input port %1"), buf) << endmsg;
-				return -1;
+
+		/* create any necessary new ports */
+		while (n_inputs().get(*t) < n) {
+
+			char buf[64];
+
+			if (_input_maximum.get(*t) == 1) {
+				snprintf (buf, sizeof (buf), _("%s/in"), _name.c_str());
+			} else {
+				snprintf (buf, sizeof (buf), _("%s/in %u"), _name.c_str(), find_input_port_hole());
 			}
-		}
 
-		catch (AudioEngine::PortRegistrationFailure& err) {
-			setup_peak_meters ();
-			reset_panner ();
-			/* pass it on */
-			throw AudioEngine::PortRegistrationFailure();
+			try {
+
+				if ((input_port = _session.engine().register_input_port (*t, buf)) == 0) {
+					error << string_compose(_("IO: cannot register input port %1"), buf) << endmsg;
+					return -1;
+				}
+			}
+
+			catch (AudioEngine::PortRegistrationFailure& err) {
+				setup_peak_meters ();
+				reset_panner ();
+				/* pass it on */
+				throw AudioEngine::PortRegistrationFailure();
+			}
+
+			_inputs.add (input_port);
+			changed = true;
 		}
-		
-		_inputs.push_back (input_port);
-		sort (_inputs.begin(), _inputs.end(), sort_ports_by_name);
-		++_ninputs;
-		changed = true;
 	}
 	
 	if (changed) {
 		drop_input_connection ();
 		setup_peak_meters ();
 		reset_panner ();
-		MoreOutputs (_ninputs); /* EMIT SIGNAL */
+		MoreChannels (n_inputs()); /* EMIT SIGNAL */
 		_session.set_dirty ();
 	}
 	
 	if (clear) {
 		/* disconnect all existing ports so that we get a fresh start */
-			
-		for (vector<Port *>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+		for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 			_session.engine().disconnect (*i);
 		}
 	}
@@ -1114,24 +838,28 @@ IO::ensure_inputs_locked (uint32_t n, bool clear, void* src)
 	return changed;
 }
 
+/** Attach output_buffers to port buffers.
+ * 
+ * Connected to IO's own MoreChannels signal.
+ */
+void
+IO::attach_buffers(ChanCount ignored)
+{
+	_output_buffers->attach_buffers(_outputs);
+}
+
 int
-IO::ensure_io (uint32_t nin, uint32_t nout, bool clear, void* src)
+IO::ensure_io (ChanCount in, ChanCount out, bool clear, void* src)
 {
-	bool in_changed = false;
-	bool out_changed = false;
-	bool in_reduced = false;
-	bool out_reduced = false;
-	bool need_pan_reset;
+	bool in_changed     = false;
+	bool out_changed    = false;
+	bool need_pan_reset = false;
 
-	if (_input_maximum >= 0) {
-		nin = min (_input_maximum, (int) nin);
-	}
+	in = min (_input_maximum, in);
 
-	if (_output_maximum >= 0) {
-		nout = min (_output_maximum, (int) nout);
-	}
+	out = min (_output_maximum, out);
 
-	if (nin == _ninputs && nout == _noutputs && !clear) {
+	if (in == n_inputs() && out == n_outputs() && !clear) {
 		return 0;
 	}
 
@@ -1141,106 +869,114 @@ IO::ensure_io (uint32_t nin, uint32_t nout, bool clear, void* src)
 
 		Port* port;
 		
-		if (_noutputs == nout) {
-			need_pan_reset = false;
-		} else {
+		if (n_outputs() != out) {
 			need_pan_reset = true;
 		}
 		
-		/* remove unused ports */
-		
-		while (_ninputs > nin) {
-			_session.engine().unregister_port (_inputs.back());
-			_inputs.pop_back();
-			_ninputs--;
-			in_reduced = true;
-			in_changed = true;
-		}
-		
-		while (_noutputs > nout) {
-			_session.engine().unregister_port (_outputs.back());
-			_outputs.pop_back();
-			_noutputs--;
-			out_reduced = true;
-			out_changed = true;
-		}
-		
-		/* create any necessary new ports (of the default type) */
-		
-		while (_ninputs < nin) {
-			
-			char buf[64];
+		for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
 
-			/* Create a new input port */
-			
-			if (_input_maximum == 1) {
-				snprintf (buf, sizeof (buf), _("%s/in"), _name.c_str());
+			const size_t nin = in.get(*t);
+			const size_t nout = out.get(*t);
+
+			Port* output_port = 0;
+			Port* input_port = 0;
+
+			/* remove unused output ports */
+			for (size_t i = n_outputs().get(*t); i > nout; --i) {
+				output_port = _outputs.port(*t, i-1);
+
+				assert(output_port);
+				_outputs.remove(output_port);
+				_session.engine().unregister_port (*output_port);
+
+				out_changed = true;
 			}
-			else {
-				snprintf (buf, sizeof (buf), _("%s/in %u"), _name.c_str(), find_input_port_hole());
+
+			/* remove unused input ports */
+			for (size_t i = n_inputs().get(*t); i > nin; --i) {
+				input_port = _inputs.port(*t, i-1);
+
+				assert(input_port);
+				_inputs.remove(input_port);
+				_session.engine().unregister_port (*input_port);
+
+				in_changed = true;
 			}
-			
-			try {
-				if ((port = _session.engine().register_input_port (_default_type, buf)) == 0) {
-					error << string_compose(_("IO: cannot register input port %1"), buf) << endmsg;
-					return -1;
+
+			/* create any necessary new input ports */
+
+			while (n_inputs().get(*t) < nin) {
+
+				char buf[64];
+
+				/* Create a new input port */
+
+				if (_input_maximum.get(*t) == 1) {
+					snprintf (buf, sizeof (buf), _("%s/in"), _name.c_str());
+				} else {
+					snprintf (buf, sizeof (buf), _("%s/in %u"), _name.c_str(), find_input_port_hole());
 				}
-			}
 
-			catch (AudioEngine::PortRegistrationFailure& err) {
-				setup_peak_meters ();
-				reset_panner ();
-				/* pass it on */
-				throw AudioEngine::PortRegistrationFailure();
-			}
-		
-			_inputs.push_back (port);
-			++_ninputs;
-			in_changed = true;
-		}
+				try {
+					if ((port = _session.engine().register_input_port (*t, buf)) == 0) {
+						error << string_compose(_("IO: cannot register input port %1"), buf) << endmsg;
+						return -1;
+					}
+				}
+				
+				catch (AudioEngine::PortRegistrationFailure& err) {
+					setup_peak_meters ();
+					reset_panner ();
+					/* pass it on */
+					throw AudioEngine::PortRegistrationFailure();
+				}
 
-		/* create any necessary new ports */
-		
-		while (_noutputs < nout) {
-			
-			char buf[64];
-			
-			/* Create a new output port */
-			
-			if (_output_maximum == 1) {
-				snprintf (buf, sizeof (buf), _("%s/out"), _name.c_str());
-			} else {
-				snprintf (buf, sizeof (buf), _("%s/out %u"), _name.c_str(), find_output_port_hole());
+				_inputs.add (port);
+				in_changed = true;
 			}
-			
-			try { 
-				if ((port = _session.engine().register_output_port (_default_type, buf)) == 0) {
-					error << string_compose(_("IO: cannot register output port %1"), buf) << endmsg;
-					return -1;
+
+			/* create any necessary new output ports */
+
+			while (n_outputs().get(*t) < nout) {
+
+				char buf[64];
+
+				/* Create a new output port */
+
+				if (_output_maximum.get(*t) == 1) {
+					snprintf (buf, sizeof (buf), _("%s/out"), _name.c_str());
+				} else {
+					snprintf (buf, sizeof (buf), _("%s/out %u"), _name.c_str(), find_output_port_hole());
 				}
+
+				try { 
+					if ((port = _session.engine().register_output_port (*t, buf)) == 0) {
+						error << string_compose(_("IO: cannot register output port %1"), buf) << endmsg;
+						return -1;
+					}
+				}
+
+				catch (AudioEngine::PortRegistrationFailure& err) {
+					setup_peak_meters ();
+					reset_panner ();
+					/* pass it on */
+					throw AudioEngine::PortRegistrationFailure ();
+				}
+
+				_outputs.add (port);
+				out_changed = true;
 			}
-			
-			catch (AudioEngine::PortRegistrationFailure& err) {
-				setup_peak_meters ();
-				reset_panner ();
-				/* pass it on */
-				throw AudioEngine::PortRegistrationFailure ();
-			}
-		
-			_outputs.push_back (port);
-			++_noutputs;
-			out_changed = true;
 		}
 		
 		if (clear) {
 			
 			/* disconnect all existing ports so that we get a fresh start */
 			
-			for (vector<Port *>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+			for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 				_session.engine().disconnect (*i);
 			}
 			
-			for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+			for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 				_session.engine().disconnect (*i);
 			}
 		}
@@ -1252,19 +988,17 @@ IO::ensure_io (uint32_t nin, uint32_t nout, bool clear, void* src)
 	}
 
 	if (out_changed) {
-		sort (_outputs.begin(), _outputs.end(), sort_ports_by_name);
 		drop_output_connection ();
 		output_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 	}
 	
 	if (in_changed) {
-		sort (_inputs.begin(), _inputs.end(), sort_ports_by_name);
 		drop_input_connection ();
 		input_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 	}
 
 	if (in_changed || out_changed) {
-		MoreOutputs (max (_noutputs, _ninputs)); /* EMIT SIGNAL */
+		MoreChannels (max (n_outputs(), n_inputs())); /* EMIT SIGNAL */
 		_session.set_dirty ();
 	}
 
@@ -1272,99 +1006,92 @@ IO::ensure_io (uint32_t nin, uint32_t nout, bool clear, void* src)
 }
 
 int
-IO::ensure_inputs (uint32_t n, bool clear, bool lockit, void* src)
+IO::ensure_inputs (ChanCount count, bool clear, bool lockit, void* src)
 {
 	bool changed = false;
 
-	if (_input_maximum >= 0) {
-		n = min (_input_maximum, (int) n);
-		
-		if (n == _ninputs && !clear) {
-			return 0;
-		}
+	count = min (_input_maximum, count);
+
+	if (count == n_inputs() && !clear) {
+		return 0;
 	}
-	
+
 	if (lockit) {
 		BLOCK_PROCESS_CALLBACK ();
 		Glib::Mutex::Lock im (io_lock);
-		changed = ensure_inputs_locked (n, clear, src);
+		changed = ensure_inputs_locked (count, clear, src);
 	} else {
-		changed = ensure_inputs_locked (n, clear, src);
+		changed = ensure_inputs_locked (count, clear, src);
 	}
 
 	if (changed) {
 		input_changed (ConfigurationChanged, src); /* EMIT SIGNAL */
 		_session.set_dirty ();
 	}
-
 	return 0;
 }
 
 bool
-IO::ensure_outputs_locked (uint32_t n, bool clear, void* src)
+IO::ensure_outputs_locked (ChanCount count, bool clear, void* src)
 {
-	Port* output_port;
-	bool changed = false;
-	bool reduced = false;
-	bool need_pan_reset;
+	Port* output_port    = 0;
+	bool  changed        = false;
+	bool  need_pan_reset = false;
 
-	if (_noutputs == n) {
-		need_pan_reset = false;
-	} else {
+	if (n_outputs() != count) {
 		need_pan_reset = true;
 	}
 	
-	/* remove unused ports */
-	
-	while (_noutputs > n) {
-		
-		_session.engine().unregister_port (_outputs.back());
-		_outputs.pop_back();
-		_noutputs--;
-		reduced = true;
-		changed = true;
-	}
-	
-	/* create any necessary new ports */
-	
-	while (_noutputs < n) {
-		
-		char buf[64];
-		
-		/* Create a new output port */
-		
-		if (_output_maximum == 1) {
-			snprintf (buf, sizeof (buf), _("%s/out"), _name.c_str());
-		} else {
-			snprintf (buf, sizeof (buf), _("%s/out %u"), _name.c_str(), find_output_port_hole());
-		}
-		
-		if ((output_port = _session.engine().register_output_port (_default_type, buf)) == 0) {
-			error << string_compose(_("IO: cannot register output port %1"), buf) << endmsg;
-			return -1;
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+
+		const size_t n = count.get(*t);
+
+		/* remove unused ports */
+		for (size_t i = n_outputs().get(*t); i > n; --i) {
+			output_port = _outputs.port(*t, i-1);
+
+			assert(output_port);
+			_outputs.remove(output_port);
+			_session.engine().unregister_port (*output_port);
+
+			changed = true;
 		}
-		
-		_outputs.push_back (output_port);
-		sort (_outputs.begin(), _outputs.end(), sort_ports_by_name);
-		++_noutputs;
-		changed = true;
-		setup_peak_meters ();
 
-		if (need_pan_reset) {
-			reset_panner ();
+		/* create any necessary new ports */
+		while (n_outputs().get(*t) < n) {
+
+			char buf[64];
+
+			if (_output_maximum.get(*t) == 1) {
+				snprintf (buf, sizeof (buf), _("%s/out"), _name.c_str());
+			} else {
+				snprintf (buf, sizeof (buf), _("%s/out %u"), _name.c_str(), find_output_port_hole());
+			}
+
+			if ((output_port = _session.engine().register_output_port (*t, buf)) == 0) {
+				error << string_compose(_("IO: cannot register output port %1"), buf) << endmsg;
+				return -1;
+			}
+
+			_outputs.add (output_port);
+			changed = true;
+			setup_peak_meters ();
+
+			if (need_pan_reset) {
+				reset_panner ();
+			}
 		}
 	}
 	
 	if (changed) {
 		drop_output_connection ();
-		MoreOutputs (_noutputs); /* EMIT SIGNAL */
+		MoreChannels (n_outputs()); /* EMIT SIGNAL */
 		_session.set_dirty ();
 	}
 	
 	if (clear) {
 		/* disconnect all existing ports so that we get a fresh start */
-		
-		for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+		for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 			_session.engine().disconnect (*i);
 		}
 	}
@@ -1373,13 +1100,13 @@ IO::ensure_outputs_locked (uint32_t n, bool clear, void* src)
 }
 
 int
-IO::ensure_outputs (uint32_t n, bool clear, bool lockit, void* src)
+IO::ensure_outputs (ChanCount count, bool clear, bool lockit, void* src)
 {
 	bool changed = false;
 
-	if (_output_maximum >= 0) {
-		n = min (_output_maximum, (int) n);
-		if (n == _noutputs && !clear) {
+	if (_output_maximum < ChanCount::INFINITE) {
+		count = min (_output_maximum, count);
+		if (count == n_outputs() && !clear) {
 			return 0;
 		}
 	}
@@ -1389,9 +1116,9 @@ IO::ensure_outputs (uint32_t n, bool clear, bool lockit, void* src)
 	if (lockit) {
 		BLOCK_PROCESS_CALLBACK ();
 		Glib::Mutex::Lock im (io_lock);
-		changed = ensure_outputs_locked (n, clear, src);
+		changed = ensure_outputs_locked (count, clear, src);
 	} else {
-		changed = ensure_outputs_locked (n, clear, src);
+		changed = ensure_outputs_locked (count, clear, src);
 	}
 
 	if (changed) {
@@ -1416,7 +1143,7 @@ IO::reset_panner ()
 {
 	if (panners_legal) {
 		if (!no_panner_reset) {
-			_panner->reset (_noutputs, pans_required());
+			_panner->reset (n_outputs().get(DataType::AUDIO), pans_required());
 		}
 	} else {
 		panner_legal_c.disconnect ();
@@ -1427,7 +1154,7 @@ IO::reset_panner ()
 int
 IO::panners_became_legal ()
 {
-	_panner->reset (_noutputs, pans_required());
+	_panner->reset (n_outputs().get(DataType::AUDIO), pans_required());
 	_panner->load (); // automation
 	panner_legal_c.disconnect ();
 	return 0;
@@ -1481,9 +1208,9 @@ IO::state (bool full_state)
 	}
 
 	if (need_ins) {
-		for (vector<Port *>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+		for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
 			
-			const char **connections = (*i)->get_connections();
+			const char **connections = i->get_connections();
 			
 			if (connections && connections[0]) {
 				str += '{';
@@ -1518,9 +1245,9 @@ IO::state (bool full_state)
 	if (need_outs) {
 		str = "";
 		
-		for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+		for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
 			
-			const char **connections = (*i)->get_connections();
+			const char **connections = i->get_connections();
 			
 			if (connections && connections[0]) {
 				
@@ -1552,11 +1279,13 @@ IO::state (bool full_state)
 	snprintf (buf, sizeof(buf), "%2.12f", gain());
 	node->add_property ("gain", buf);
 
-	snprintf (buf, sizeof(buf)-1, "%d,%d,%d,%d",
-		  _input_minimum,
-		  _input_maximum,
-		  _output_minimum,
-		  _output_maximum);
+	// FIXME: this is NOT sufficient!
+	const int in_min  = (_input_minimum == ChanCount::ZERO) ? -1 : _input_minimum.get(_default_type);
+	const int in_max  = (_input_maximum == ChanCount::INFINITE) ? -1 : _input_maximum.get(_default_type);
+	const int out_min = (_output_minimum == ChanCount::ZERO) ? -1 : _output_minimum.get(_default_type);
+	const int out_max = (_output_maximum == ChanCount::INFINITE) ? -1 : _output_maximum.get(_default_type);
+
+	snprintf (buf, sizeof(buf)-1, "%d,%d,%d,%d", in_min, in_max, out_min, out_max);
 
 	node->add_property ("iolimits", buf);
 
@@ -1602,12 +1331,18 @@ IO::set_state (const XMLNode& node)
 		_id = prop->value ();
 	}
 
+	size_t in_min =  -1;
+	size_t in_max  = -1;
+	size_t out_min = -1;
+	size_t out_max = -1;
+
 	if ((prop = node.property ("iolimits")) != 0) {
-		sscanf (prop->value().c_str(), "%d,%d,%d,%d", 
-			&_input_minimum,
-			&_input_maximum,
-			&_output_minimum,
-			&_output_maximum);
+		sscanf (prop->value().c_str(), "%zd,%zd,%zd,%zd",
+			&in_min, &in_max, &out_min, &out_max);
+		_input_minimum = ChanCount(_default_type, in_min);
+		_input_maximum = ChanCount(_default_type, in_max);
+		_output_minimum = ChanCount(_default_type, out_min);
+		_output_maximum = ChanCount(_default_type, out_max);
 	}
 	
 	if ((prop = node.property ("gain")) != 0) {
@@ -1722,7 +1457,7 @@ IO::load_automation (string path)
 
 	while (in.getline (line, sizeof(line), '\n')) {
 		char type;
-		jack_nframes_t when;
+		nframes_t when;
 		double value;
 
 		if (++linecnt == 1) {
@@ -1867,7 +1602,8 @@ IO::create_ports (const XMLNode& node)
 
 	no_panner_reset = true;
 
-	if (ensure_io (num_inputs, num_outputs, true, this)) {
+	// FIXME: audio-only
+	if (ensure_io (ChanCount(DataType::AUDIO, num_inputs), ChanCount(DataType::AUDIO, num_outputs), true, this)) {
 		error << string_compose(_("%1: cannot create I/O ports"), _name) << endmsg;
 		return -1;
 	}
@@ -1951,7 +1687,8 @@ IO::set_inputs (const string& str)
 		return 0;
 	}
 
-	if (ensure_inputs (nports, true, true, this)) {
+	// FIXME: audio-only
+	if (ensure_inputs (ChanCount(DataType::AUDIO, nports), true, true, this)) {
 		return -1;
 	}
 
@@ -2001,7 +1738,8 @@ IO::set_outputs (const string& str)
 		return 0;
 	}
 
-	if (ensure_outputs (nports, true, true, this)) {
+	// FIXME: audio-only
+	if (ensure_outputs (ChanCount(DataType::AUDIO, nports), true, true, this)) {
 		return -1;
 	}
 
@@ -2099,16 +1837,16 @@ IO::set_name (string name, void* src)
 		warning << _("you cannot use colons to name objects with I/O connections") << endmsg;
 	}
 
-	for (vector<Port *>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
-		string current_name = (*i)->short_name();
+	for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+		string current_name = i->short_name();
 		current_name.replace (current_name.find (_name), _name.length(), name);
-		(*i)->set_name (current_name);
+		i->set_name (current_name);
 	}
 
-	for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
-		string current_name = (*i)->short_name();
+	for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+		string current_name = i->short_name();
 		current_name.replace (current_name.find (_name), _name.length(), name);
-		(*i)->set_name (current_name);
+		i->set_name (current_name);
 	}
 
 	_name = name;
@@ -2118,25 +1856,25 @@ IO::set_name (string name, void* src)
 }
 
 void
-IO::set_input_minimum (int n)
+IO::set_input_minimum (ChanCount n)
 {
 	_input_minimum = n;
 }
 
 void
-IO::set_input_maximum (int n)
+IO::set_input_maximum (ChanCount n)
 {
 	_input_maximum = n;
 }
 
 void
-IO::set_output_minimum (int n)
+IO::set_output_minimum (ChanCount n)
 {
 	_output_minimum = n;
 }
 
 void
-IO::set_output_maximum (int n)
+IO::set_output_maximum (ChanCount n)
 {
 	_output_maximum = n;
 }
@@ -2146,8 +1884,8 @@ IO::set_port_latency (nframes_t nframes)
 {
 	Glib::Mutex::Lock lm (io_lock);
 
-	for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
-		(*i)->set_latency (nframes);
+	for (PortSet::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+		i->set_latency (nframes);
 	}
 }
 
@@ -2161,8 +1899,8 @@ IO::output_latency () const
 
 	/* io lock not taken - must be protected by other means */
 
-	for (vector<Port *>::const_iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
-		if ((latency = _session.engine().get_port_total_latency (*(*i))) > max_latency) {
+	for (PortSet::const_iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
+		if ((latency = _session.engine().get_port_total_latency (*i)) > max_latency) {
 			max_latency = latency;
 		}
 	}
@@ -2180,8 +1918,8 @@ IO::input_latency () const
 
 	/* io lock not taken - must be protected by other means */
 
-	for (vector<Port *>::const_iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
-		if ((latency = _session.engine().get_port_total_latency (*(*i))) > max_latency) {
+	for (PortSet::const_iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+		if ((latency = _session.engine().get_port_total_latency (*i)) > max_latency) {
 			max_latency = latency;
 		}
 	}
@@ -2202,7 +1940,8 @@ IO::use_input_connection (Connection& c, void* src)
 		
 		drop_input_connection ();
 		
-		if (ensure_inputs (limit, false, false, src)) {
+		// FIXME connections only work for audio-only
+		if (ensure_inputs (ChanCount(DataType::AUDIO, limit), false, false, src)) {
 			return -1;
 		}
 
@@ -2215,13 +1954,13 @@ IO::use_input_connection (Connection& c, void* src)
 			
 			for (Connection::PortList::const_iterator i = pl.begin(); i != pl.end(); ++i) {
 				
-				if (!_inputs[n]->connected_to ((*i))) {
+				if (!_inputs.port(n)->connected_to ((*i))) {
 					
 					/* clear any existing connections */
 					
-					_session.engine().disconnect (_inputs[n]);
+					_session.engine().disconnect (*_inputs.port(n));
 					
-				} else if (_inputs[n]->connected() > 1) {
+				} else if (_inputs.port(n)->connected() > 1) {
 					
 					/* OK, it is connected to the port we want,
 					   but its also connected to other ports.
@@ -2232,7 +1971,7 @@ IO::use_input_connection (Connection& c, void* src)
 					   the one we want.
 					*/
 					
-					_session.engine().disconnect (_inputs[n]);
+					_session.engine().disconnect (*_inputs.port(n));
 					
 				}
 			}
@@ -2245,9 +1984,9 @@ IO::use_input_connection (Connection& c, void* src)
 			
 			for (Connection::PortList::const_iterator i = pl.begin(); i != pl.end(); ++i) {
 				
-				if (!_inputs[n]->connected_to ((*i))) {
+				if (!_inputs.port(n)->connected_to ((*i))) {
 					
-					if (_session.engine().connect (*i, _inputs[n]->name())) {
+					if (_session.engine().connect (*i, _inputs.port(n)->name())) {
 						return -1;
 					}
 				}
@@ -2280,7 +2019,8 @@ IO::use_output_connection (Connection& c, void* src)
 			
 		drop_output_connection ();
 
-		if (ensure_outputs (limit, false, false, src)) {
+		// FIXME: audio-only
+		if (ensure_outputs (ChanCount(DataType::AUDIO, limit), false, false, src)) {
 			return -1;
 		}
 
@@ -2294,13 +2034,13 @@ IO::use_output_connection (Connection& c, void* src)
 				
 			for (Connection::PortList::const_iterator i = pl.begin(); i != pl.end(); ++i) {
 					
-				if (!_outputs[n]->connected_to ((*i))) {
+				if (!_outputs.port(n)->connected_to ((*i))) {
 
 					/* clear any existing connections */
 
-					_session.engine().disconnect (_outputs[n]);
+					_session.engine().disconnect (*_outputs.port(n));
 
-				} else if (_outputs[n]->connected() > 1) {
+				} else if (_outputs.port(n)->connected() > 1) {
 
 					/* OK, it is connected to the port we want,
 					   but its also connected to other ports.
@@ -2311,7 +2051,7 @@ IO::use_output_connection (Connection& c, void* src)
 					   the one we want.
 					*/
 						
-					_session.engine().disconnect (_outputs[n]);
+					_session.engine().disconnect (*_outputs.port(n));
 				}
 			}
 		}
@@ -2324,9 +2064,9 @@ IO::use_output_connection (Connection& c, void* src)
 				
 			for (Connection::PortList::const_iterator i = pl.begin(); i != pl.end(); ++i) {
 					
-				if (!_outputs[n]->connected_to ((*i))) {
+				if (!_outputs.port(n)->connected_to ((*i))) {
 						
-					if (_session.engine().connect (_outputs[n]->name(), *i)) {
+					if (_session.engine().connect (_outputs.port(n)->name(), *i)) {
 						return -1;
 					}
 				}
@@ -2425,35 +2165,9 @@ IO::GainControllable::get_value (void) const
 }
 
 void
-IO::reset_peak_meters ()
-{
-	uint32_t limit = max (_ninputs, _noutputs);
-
-	for (uint32_t i = 0; i < limit; ++i) {
-		_peak_power[i] = 0;
-	}
-}
-
-void
-IO::reset_max_peak_meters ()
+IO::setup_peak_meters()
 {
-	uint32_t limit = max (_ninputs, _noutputs);
-
-	for (uint32_t i = 0; i < limit; ++i) {
-		_max_peak_power[i] = -INFINITY;
-	}
-}
-
-void
-IO::setup_peak_meters ()
-{
-	uint32_t limit = max (_ninputs, _noutputs);
-
-	while (_peak_power.size() < limit) {
-		_peak_power.push_back (0);
-		_visible_peak_power.push_back (-INFINITY);
-		_max_peak_power.push_back (-INFINITY);
-	}
+	_meter->setup(std::max(_inputs.count(), _outputs.count()));
 }
 
 /**
@@ -2469,45 +2183,16 @@ IO::update_meters()
 {
     Glib::Mutex::Lock guard (m_meter_signal_lock);
     
-    Meter();
+    Meter(); /* EMIT SIGNAL */
 }
 
 void
 IO::meter ()
 {
-	Glib::Mutex::Lock lm (io_lock); // READER: meter thread.
-	uint32_t limit = max (_ninputs, _noutputs);
+	// FIXME: Ugly.  Meter should manage the lock, if it's necessary
 	
-	for (uint32_t n = 0; n < limit; ++n) {
-
-		/* XXX we should use atomic exchange here */
-
-		/* grab peak since last read */
-
- 		float new_peak = _peak_power[n];
-		_peak_power[n] = 0;
-
-		/* compute new visible value using falloff */
-
-		if (new_peak > 0.0f) {
-			new_peak = coefficient_to_dB (new_peak);
-		} else {
-			new_peak = -INFINITY;
-		}
-
-		/* update max peak */
-		
-		_max_peak_power[n] = max (new_peak, _max_peak_power[n]);
-		
-		
-		if (Config->get_meter_falloff() == 0.0f || new_peak > _visible_peak_power[n]) {
-			_visible_peak_power[n] = new_peak;
-		} else {
-			// do falloff, the config value is in dB/sec, we get updated at 100/sec currently (should be a var somewhere)
-			new_peak = _visible_peak_power[n] - (Config->get_meter_falloff() * 0.01f);
-			_visible_peak_power[n] = max (new_peak, -INFINITY);
-		}
-	}
+	Glib::Mutex::Lock lm (io_lock); // READER: meter thread.
+	_meter->meter();
 }
 
 void
@@ -2671,12 +2356,12 @@ IO::find_input_port_hole ()
 
 	for (n = 1; n < UINT_MAX; ++n) {
 		char buf[jack_port_name_size()];
-		vector<Port*>::iterator i;
+		PortSet::iterator i = _inputs.begin();
 
 		snprintf (buf, jack_port_name_size(), _("%s/in %u"), _name.c_str(), n);
 
-		for (i = _inputs.begin(); i != _inputs.end(); ++i) {
-			if ((*i)->short_name() == buf) {
+		for ( ; i != _inputs.end(); ++i) {
+			if (i->short_name() == buf) {
 				break;
 			}
 		}
@@ -2701,12 +2386,12 @@ IO::find_output_port_hole ()
 
 	for (n = 1; n < UINT_MAX; ++n) {
 		char buf[jack_port_name_size()];
-		vector<Port*>::iterator i;
+		PortSet::iterator i = _outputs.begin();
 
 		snprintf (buf, jack_port_name_size(), _("%s/out %u"), _name.c_str(), n);
 
-		for (i = _outputs.begin(); i != _outputs.end(); ++i) {
-			if ((*i)->short_name() == buf) {
+		for ( ; i != _outputs.end(); ++i) {
+			if (i->short_name() == buf) {
 				break;
 			}
 		}
@@ -2718,3 +2403,37 @@ IO::find_output_port_hole ()
 	
 	return n;
 }
+
+AudioPort*
+IO::audio_input(uint32_t n) const
+{
+	return dynamic_cast<AudioPort*>(input(n));
+}
+
+AudioPort*
+IO::audio_output(uint32_t n) const
+{
+	return dynamic_cast<AudioPort*>(output(n));
+}
+
+MidiPort*
+IO::midi_input(uint32_t n) const
+{
+	return dynamic_cast<MidiPort*>(input(n));
+}
+
+MidiPort*
+IO::midi_output(uint32_t n) const
+{
+	return dynamic_cast<MidiPort*>(output(n));
+}
+
+void
+IO::set_phase_invert (bool yn, void *src)
+{
+	if (_phase_invert != yn) {
+		_phase_invert = yn;
+	}
+	//  phase_invert_changed (src); /* EMIT SIGNAL */
+}
+
diff --git a/libs/ardour/ladspa_plugin.cc b/libs/ardour/ladspa_plugin.cc
index 6d55423e37..082d673fbc 100644
--- a/libs/ardour/ladspa_plugin.cc
+++ b/libs/ardour/ladspa_plugin.cc
@@ -17,6 +17,9 @@
 
 */
 
+#define __STDC_FORMAT_MACROS 1
+#include <inttypes.h>
+
 #include <vector>
 #include <string>
 
@@ -40,6 +43,7 @@
 #include <ardour/session.h>
 #include <ardour/audioengine.h>
 #include <ardour/ladspa_plugin.h>
+#include <ardour/buffer_set.h>
 
 #include <pbd/stl_delete.h>
 
@@ -157,6 +161,33 @@ LadspaPlugin::~LadspaPlugin ()
 	}
 }
 
+void
+LadspaPlugin::store_state (PluginState& state)
+{
+	state.parameters.clear ();
+	
+	for (uint32_t i = 0; i < parameter_count(); ++i){
+
+		if (LADSPA_IS_PORT_INPUT(port_descriptor (i)) && 
+		    LADSPA_IS_PORT_CONTROL(port_descriptor (i))){
+			pair<uint32_t,float> datum;
+
+			datum.first = i;
+			datum.second = shadow_data[i];
+
+			state.parameters.insert (datum);
+		}
+	}
+}
+
+void
+LadspaPlugin::restore_state (PluginState& state)
+{
+	for (map<uint32_t,float>::iterator i = state.parameters.begin(); i != state.parameters.end(); ++i) {
+		set_parameter (i->first, i->second);
+	}
+}
+
 float
 LadspaPlugin::default_value (uint32_t port)
 {
@@ -471,7 +502,7 @@ LadspaPlugin::describe_parameter (uint32_t which)
 	}
 }
 
-nframes_t
+ARDOUR::nframes_t
 LadspaPlugin::latency () const
 {
 	if (latency_control_port) {
@@ -498,26 +529,28 @@ LadspaPlugin::automatable () const
 }
 
 int
-LadspaPlugin::connect_and_run (vector<Sample*>& bufs, uint32_t nbufs, int32_t& in_index, int32_t& out_index, nframes_t nframes, nframes_t offset)
+LadspaPlugin::connect_and_run (BufferSet& bufs, uint32_t& in_index, uint32_t& out_index, nframes_t nframes, nframes_t offset)
 {
-	uint32_t port_index;
+	uint32_t port_index = 0;
 	cycles_t then, now;
 
-	port_index = 0;
-
 	then = get_cycles ();
 
+	const uint32_t nbufs = bufs.count().get(DataType::AUDIO);
+
 	while (port_index < parameter_count()) {
 		if (LADSPA_IS_PORT_AUDIO (port_descriptor(port_index))) {
 			if (LADSPA_IS_PORT_INPUT (port_descriptor(port_index))) {
-				connect_port (port_index, bufs[min((uint32_t) in_index,nbufs - 1)] + offset);
+				const size_t index = min(in_index, nbufs - 1);
+				connect_port (port_index, bufs.get_audio(index).data(nframes, offset));
 				//cerr << this << ' ' << name() << " @ " << offset << " inport " << in_index << " = buf " 
 				//     << min((uint32_t)in_index,nbufs) << " = " << &bufs[min((uint32_t)in_index,nbufs)][offset] << endl;
 				in_index++;
 
 
 			} else if (LADSPA_IS_PORT_OUTPUT (port_descriptor (port_index))) {
-				connect_port (port_index, bufs[min((uint32_t) out_index,nbufs - 1)] + offset);
+				const size_t index = min(out_index,nbufs - 1);
+				connect_port (port_index, bufs.get_audio(index).data(nframes, offset));
 				// cerr << this << ' ' << name() << " @ " << offset << " outport " << out_index << " = buf " 
 				//     << min((uint32_t)out_index,nbufs) << " = " << &bufs[min((uint32_t)out_index,nbufs)][offset] << endl;
 				out_index++;
diff --git a/libs/ardour/meter.cc b/libs/ardour/meter.cc
new file mode 100644
index 0000000000..4a873600f6
--- /dev/null
+++ b/libs/ardour/meter.cc
@@ -0,0 +1,130 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <ardour/meter.h>
+#include <algorithm>
+#include <cmath>
+#include <ardour/buffer_set.h>
+#include <ardour/peak.h>
+#include <ardour/dB.h>
+#include <ardour/session.h>
+
+namespace ARDOUR {
+
+
+/** Get peaks from @a bufs
+ * Input acceptance is lenient - the first n audio buffers from @a bufs will
+ * be metered, where n was set by the last call to setup(), excess meters will
+ * be set to 0.
+ */
+void
+PeakMeter::run (BufferSet& bufs, nframes_t nframes, nframes_t offset)
+{
+	size_t meterable = std::min(bufs.count().get(DataType::AUDIO), _peak_power.size());
+
+	// Meter what we have
+	for (size_t n = 0; n < meterable; ++n) {
+		_peak_power[n] = compute_peak (bufs.get_audio(n).data(nframes, offset), nframes, _peak_power[n]); 
+	}
+
+	// Zero any excess peaks
+	for (size_t n = meterable; n < _peak_power.size(); ++n) {
+		_peak_power[n] = 0;
+	}
+}
+
+void
+PeakMeter::reset ()
+{
+	for (size_t i = 0; i < _peak_power.size(); ++i) {
+		_peak_power[i] = 0;
+	}
+}
+
+void
+PeakMeter::reset_max ()
+{
+	for (size_t i = 0; i < _max_peak_power.size(); ++i) {
+		_max_peak_power[i] = -INFINITY;
+	}
+}
+
+void
+PeakMeter::setup (const ChanCount& in)
+{
+	uint32_t limit = in.get(DataType::AUDIO);
+
+	while (_peak_power.size() > limit) {
+		_peak_power.pop_back();
+		_visible_peak_power.pop_back();
+		_max_peak_power.pop_back();
+	}
+
+	while (_peak_power.size() < limit) {
+		_peak_power.push_back(0);
+		_visible_peak_power.push_back(minus_infinity());
+		_max_peak_power.push_back(minus_infinity());
+	}
+
+	assert(_peak_power.size() == limit);
+	assert(_visible_peak_power.size() == limit);
+	assert(_max_peak_power.size() == limit);
+}
+
+/** To be driven by the Meter signal from IO.
+ * Caller MUST hold io_lock!
+ */
+void
+PeakMeter::meter ()
+{
+	assert(_visible_peak_power.size() == _peak_power.size());
+
+	const size_t limit = _peak_power.size();
+
+	for (size_t n = 0; n < limit; ++n) {
+
+		/* XXX we should use atomic exchange here */
+
+		/* grab peak since last read */
+
+ 		float new_peak = _peak_power[n];
+		_peak_power[n] = 0;
+		
+		/* compute new visible value using falloff */
+
+		if (new_peak > 0.0) {
+			new_peak = coefficient_to_dB (new_peak);
+		} else {
+			new_peak = minus_infinity();
+		}
+		
+		/* update max peak */
+		
+		_max_peak_power[n] = std::max (new_peak, _max_peak_power[n]);
+		
+		if (Config->get_meter_falloff() == 0.0f || new_peak > _visible_peak_power[n]) {
+			_visible_peak_power[n] = new_peak;
+		} else {
+			// do falloff
+			new_peak = _visible_peak_power[n] - (Config->get_meter_falloff() * 0.01f);
+			_visible_peak_power[n] = std::max (new_peak, -INFINITY);
+		}
+	}
+}
+
+} // namespace ARDOUR
diff --git a/libs/ardour/midi_diskstream.cc b/libs/ardour/midi_diskstream.cc
new file mode 100644
index 0000000000..552311115d
--- /dev/null
+++ b/libs/ardour/midi_diskstream.cc
@@ -0,0 +1,1527 @@
+/*
+    Copyright (C) 2000-2003 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <fstream>
+#include <cstdio>
+#include <unistd.h>
+#include <cmath>
+#include <cerrno>
+#include <string>
+#include <climits>
+#include <fcntl.h>
+#include <cstdlib>
+#include <ctime>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include <pbd/error.h>
+#include <pbd/basename.h>
+#include <glibmm/thread.h>
+#include <pbd/xml++.h>
+#include <pbd/memento_command.h>
+#include <pbd/enumwriter.h>
+
+#include <ardour/ardour.h>
+#include <ardour/audioengine.h>
+#include <ardour/midi_diskstream.h>
+#include <ardour/utils.h>
+#include <ardour/configuration.h>
+#include <ardour/smf_source.h>
+#include <ardour/send.h>
+#include <ardour/region_factory.h>
+#include <ardour/midi_playlist.h>
+#include <ardour/playlist_factory.h>
+#include <ardour/cycle_timer.h>
+#include <ardour/midi_region.h>
+#include <ardour/midi_port.h>
+
+#include "i18n.h"
+#include <locale.h>
+
+using namespace std;
+using namespace ARDOUR;
+using namespace PBD;
+
+MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
+	: Diskstream(sess, name, flag)
+	, _playback_buf(0)
+	, _capture_buf(0)
+	//, _current_playback_buffer(0)
+	//, _current_capture_buffer(0)
+	//, _playback_wrap_buffer(0)
+	//, _capture_wrap_buffer(0)
+	, _source_port(0)
+	, _capture_transition_buf(0)
+	, _last_flush_frame(0)
+{
+	/* prevent any write sources from being created */
+
+	in_set_state = true;
+
+	init(flag);
+	use_new_playlist ();
+
+	in_set_state = false;
+
+	assert(!destructive());
+}
+	
+MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
+	: Diskstream(sess, node)
+	, _playback_buf(0)
+	, _capture_buf(0)
+	//, _current_playback_buffer(0)
+	//, _current_capture_buffer(0)
+	//, _playback_wrap_buffer(0)
+	//, _capture_wrap_buffer(0)
+	, _source_port(0)
+	, _capture_transition_buf(0)
+	, _last_flush_frame(0)
+{
+	in_set_state = true;
+	init (Recordable);
+
+	if (set_state (node)) {
+		in_set_state = false;
+		throw failed_constructor();
+	}
+
+	in_set_state = false;
+
+	if (destructive()) {
+		use_destructive_playlist ();
+	}
+}
+
+void
+MidiDiskstream::init (Diskstream::Flag f)
+{
+	Diskstream::init(f);
+
+	/* there are no channels at this point, so these
+	   two calls just get speed_buffer_size and wrap_buffer
+	   size setup without duplicating their code.
+	*/
+
+	set_block_size (_session.get_block_size());
+	allocate_temporary_buffers ();
+
+	//_playback_wrap_buffer = new RawMidi[wrap_buffer_size];
+	//_capture_wrap_buffer = new RawMidi[wrap_buffer_size];
+	_playback_buf = new MidiRingBuffer (_session.diskstream_buffer_size());
+	_capture_buf = new MidiRingBuffer (_session.diskstream_buffer_size());
+	_capture_transition_buf = new RingBufferNPT<CaptureTransition> (128);
+	
+	_n_channels = ChanCount(DataType::MIDI, 1);
+
+	assert(recordable());
+}
+
+MidiDiskstream::~MidiDiskstream ()
+{
+	Glib::Mutex::Lock lm (state_lock);
+}
+
+void
+MidiDiskstream::non_realtime_input_change ()
+{
+	{ 
+		Glib::Mutex::Lock lm (state_lock);
+
+		if (input_change_pending == NoChange) {
+			return;
+		}
+
+		if (input_change_pending & ConfigurationChanged) {
+
+			assert(_io->n_inputs() == _n_channels);
+		} 
+
+		get_input_sources ();
+		set_capture_offset ();
+
+		if (first_input_change) {
+			set_align_style (_persistent_alignment_style);
+			first_input_change = false;
+		} else {
+			set_align_style_from_io ();
+		}
+
+		input_change_pending = NoChange;
+	}
+
+	/* reset capture files */
+
+	reset_write_sources (false);
+
+	/* now refill channel buffers */
+
+	if (speed() != 1.0f || speed() != -1.0f) {
+		seek ((nframes_t) (_session.transport_frame() * (double) speed()));
+	}
+	else {
+		seek (_session.transport_frame());
+	}
+
+	_last_flush_frame = _session.transport_frame();
+}
+
+void
+MidiDiskstream::get_input_sources ()
+{
+	uint32_t ni = _io->n_inputs().get(DataType::MIDI);
+
+	if (ni == 0) {
+		return;
+	}
+
+	// This is all we do for now at least
+	assert(ni == 1);
+
+	_source_port = _io->midi_input(0);
+
+	/* I don't get it....
+	const char **connections = _io->input(0)->get_connections ();
+
+	if (connections == 0 || connections[0] == 0) {
+
+		if (_source_port) {
+			// _source_port->disable_metering ();
+		}
+
+		_source_port = 0;
+
+	} else {
+		_source_port = dynamic_cast<MidiPort*>(
+			_session.engine().get_port_by_name (connections[0]) );
+	}
+
+	if (connections) {
+		free (connections);
+	}*/
+}		
+
+int
+MidiDiskstream::find_and_use_playlist (const string& name)
+{
+	boost::shared_ptr<MidiPlaylist> playlist;
+		
+	if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlist_by_name (name))) == 0) {
+		playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
+	}
+
+	if (!playlist) {
+		error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
+		return -1;
+	}
+
+	return use_playlist (playlist);
+}
+
+int
+MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
+{	
+	assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
+
+	Diskstream::use_playlist(playlist);
+
+	return 0;
+}
+
+int
+MidiDiskstream::use_new_playlist ()
+{	
+	string newname;
+	boost::shared_ptr<MidiPlaylist> playlist;
+
+	if (!in_set_state && destructive()) {
+		return 0;
+	}
+
+	if (_playlist) {
+		newname = Playlist::bump_name (_playlist->name(), _session);
+	} else {
+		newname = Playlist::bump_name (_name, _session);
+	}
+
+	if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
+			DataType::MIDI, _session, newname, hidden()))) != 0) {
+		
+		playlist->set_orig_diskstream_id (id());
+		return use_playlist (playlist);
+
+	} else { 
+		return -1;
+	}
+}
+
+int
+MidiDiskstream::use_copy_playlist ()
+{
+	assert(midi_playlist());
+
+	if (destructive()) {
+		return 0;
+	}
+
+	if (_playlist == 0) {
+		error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
+		return -1;
+	}
+
+	string newname;
+	boost::shared_ptr<MidiPlaylist> playlist;
+
+	newname = Playlist::bump_name (_playlist->name(), _session);
+	
+	if ((playlist  = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
+		playlist->set_orig_diskstream_id (id());
+		return use_playlist (playlist);
+	} else { 
+		return -1;
+	}
+}
+
+/** Overloaded from parent to die horribly
+ */
+int
+MidiDiskstream::set_destructive (bool yn)
+{
+	assert( ! destructive());
+	assert( ! yn);
+	return -1;
+}
+
+void
+MidiDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
+{
+	// FIXME: waaay too much code to duplicate (AudioDiskstream)
+	
+	int possibly_recording;
+	int rolling;
+	int change;
+	const int transport_rolling = 0x4;
+	const int track_rec_enabled = 0x2;
+	const int global_rec_enabled = 0x1;
+
+	/* merge together the 3 factors that affect record status, and compute
+	   what has changed.
+	*/
+
+	rolling = _session.transport_speed() != 0.0f;
+	possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
+	change = possibly_recording ^ last_possibly_recording;
+
+	if (possibly_recording == last_possibly_recording) {
+		return;
+	}
+
+	/* change state */
+
+	/* if per-track or global rec-enable turned on while the other was already on, we've started recording */
+
+	if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) || 
+	    ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
+		
+		/* starting to record: compute first+last frames */
+
+		first_recordable_frame = transport_frame + _capture_offset;
+		last_recordable_frame = max_frames;
+		capture_start_frame = transport_frame;
+
+		if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
+
+			/* was stopped, now rolling (and recording) */
+
+			if (_alignment_style == ExistingMaterial) {
+				first_recordable_frame += _session.worst_output_latency();
+			} else {
+				first_recordable_frame += _roll_delay;
+  			}
+
+		} else {
+
+			/* was rolling, but record state changed */
+
+			if (_alignment_style == ExistingMaterial) {
+
+
+				if (!Config->get_punch_in()) {
+
+					/* manual punch in happens at the correct transport frame
+					   because the user hit a button. but to get alignment correct 
+					   we have to back up the position of the new region to the 
+					   appropriate spot given the roll delay.
+					*/
+
+					capture_start_frame -= _roll_delay;
+
+					/* XXX paul notes (august 2005): i don't know why
+					   this is needed.
+					*/
+
+					first_recordable_frame += _capture_offset;
+
+				} else {
+
+					/* autopunch toggles recording at the precise
+					   transport frame, and then the DS waits
+					   to start recording for a time that depends
+					   on the output latency.
+					*/
+
+					first_recordable_frame += _session.worst_output_latency();
+				}
+
+			} else {
+
+				if (Config->get_punch_in()) {
+					first_recordable_frame += _roll_delay;
+				} else {
+					capture_start_frame -= _roll_delay;
+				}
+			}
+			
+		}
+
+		if (_flags & Recordable) {
+			RingBufferNPT<CaptureTransition>::rw_vector transvec;
+			_capture_transition_buf->get_write_vector(&transvec);
+
+			if (transvec.len[0] > 0) {
+				transvec.buf[0]->type = CaptureStart;
+				transvec.buf[0]->capture_val = capture_start_frame;
+				_capture_transition_buf->increment_write_ptr(1);
+			} else {
+				// bad!
+				fatal << X_("programming error: capture_transition_buf is full on rec start!  inconceivable!") 
+					<< endmsg;
+			}
+		}
+
+	} else if (!record_enabled() || !can_record) {
+		
+		/* stop recording */
+
+		last_recordable_frame = transport_frame + _capture_offset;
+		
+		if (_alignment_style == ExistingMaterial) {
+			last_recordable_frame += _session.worst_output_latency();
+		} else {
+			last_recordable_frame += _roll_delay;
+		}
+	}
+
+	last_possibly_recording = possibly_recording;
+}
+
+int
+MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
+{
+	// FIXME: waay too much code to duplicate (AudioDiskstream::process)
+	int            ret = -1;
+	nframes_t rec_offset = 0;
+	nframes_t rec_nframes = 0;
+	bool           nominally_recording;
+	bool           re = record_enabled ();
+	bool           collect_playback = false;
+
+	/*_current_capture_buffer = 0;
+	  _current_playback_buffer = 0;*/
+
+	/* if we've already processed the frames corresponding to this call,
+	   just return. this allows multiple routes that are taking input
+	   from this diskstream to call our ::process() method, but have
+	   this stuff only happen once. more commonly, it allows both
+	   the AudioTrack that is using this AudioDiskstream *and* the Session
+	   to call process() without problems.
+	   */
+
+	if (_processed) {
+		return 0;
+	}
+
+	check_record_status (transport_frame, nframes, can_record);
+
+	nominally_recording = (can_record && re);
+
+	if (nframes == 0) {
+		_processed = true;
+		return 0;
+	}
+
+	/* This lock is held until the end of AudioDiskstream::commit, so these two functions
+	   must always be called as a pair. The only exception is if this function
+	   returns a non-zero value, in which case, ::commit should not be called.
+	   */
+
+	// If we can't take the state lock return.
+	if (!state_lock.trylock()) {
+		return 1;
+	}
+
+	adjust_capture_position = 0;
+
+	if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
+		OverlapType ot;
+
+		ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+
+		switch (ot) {
+			case OverlapNone:
+				rec_nframes = 0;
+				break;
+
+			case OverlapInternal:
+				/*     ----------    recrange
+					   |---|       transrange
+					   */
+				rec_nframes = nframes;
+				rec_offset = 0;
+				break;
+
+			case OverlapStart:
+				/*    |--------|    recrange
+					  -----|          transrange
+					  */
+				rec_nframes = transport_frame + nframes - first_recordable_frame;
+				if (rec_nframes) {
+					rec_offset = first_recordable_frame - transport_frame;
+				}
+				break;
+
+			case OverlapEnd:
+				/*    |--------|    recrange
+					  |--------  transrange
+					  */
+				rec_nframes = last_recordable_frame - transport_frame;
+				rec_offset = 0;
+				break;
+
+			case OverlapExternal:
+				/*    |--------|    recrange
+					  --------------  transrange
+					  */
+				rec_nframes = last_recordable_frame - last_recordable_frame;
+				rec_offset = first_recordable_frame - transport_frame;
+				break;
+		}
+
+		if (rec_nframes && !was_recording) {
+			capture_captured = 0;
+			was_recording = true;
+		}
+	}
+
+
+	if (can_record && !_last_capture_regions.empty()) {
+		_last_capture_regions.clear ();
+	}
+
+	if (nominally_recording || rec_nframes) {
+
+		assert(_source_port);
+
+		// Pump entire port buffer into the ring buffer (FIXME!)
+		_capture_buf->write(_source_port->get_midi_buffer(), transport_frame);
+
+		// FIXME: hackitty hack, don't come back
+		//_write_source->ViewDataRangeReady (_write_source->length(), rec_nframes); /* EMIT SIGNAL */
+		/*
+		   for (size_t i=0; i < _source_port->size(); ++i) {
+		   cerr << "DISKSTREAM GOT EVENT(1) " << i << "!!\n";
+		   }
+
+		   if (_source_port->size() == 0)
+		   cerr << "No events :/ (1)\n";
+		   */
+	} else {
+
+		if (was_recording) {
+			finish_capture (rec_monitors_input);
+		}
+
+	}
+
+	if (rec_nframes) {
+
+		/* XXX XXX XXX XXX XXX XXX XXX XXX */
+		/* data will be written to disk */
+
+		adjust_capture_position = rec_nframes;
+
+	} else if (nominally_recording) {
+
+		/* can't do actual capture yet - waiting for latency effects to finish before we start*/
+
+		// Ummm.. well, I suppose we'll just hang out for a bit?
+
+		playback_distance = nframes;
+
+	} else {
+
+		collect_playback = true;
+	}
+
+	if (collect_playback) {
+
+		/* we're doing playback */
+
+		nframes_t necessary_samples;
+
+		/* no varispeed playback if we're recording, because the output .... TBD */
+
+		if (rec_nframes == 0 && _actual_speed != 1.0f) {
+			necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
+		} else {
+			necessary_samples = nframes;
+		}
+
+		// XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
+		// Write into playback buffer here, and whatnot
+
+	}
+
+	ret = 0;
+
+	_processed = true;
+
+	if (ret) {
+
+		/* we're exiting with failure, so ::commit will not
+		   be called. unlock the state lock.
+		   */
+
+		state_lock.unlock();
+	} 
+
+	return ret;
+
+	_processed = true;
+
+	return 0;
+}
+
+bool
+MidiDiskstream::commit (nframes_t nframes)
+{
+	bool need_butler = false;
+
+	if (_actual_speed < 0.0) {
+		playback_sample -= playback_distance;
+	} else {
+		playback_sample += playback_distance;
+	}
+
+	/* XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX */
+
+	/*
+	_playback_buf->increment_read_ptr (playback_distance);
+
+	if (adjust_capture_position) {
+		_capture_buf->increment_write_ptr (adjust_capture_position);
+	}
+*/
+	if (adjust_capture_position != 0) {
+		capture_captured += adjust_capture_position;
+		adjust_capture_position = 0;
+	}
+
+	if (_slaved) {
+		need_butler = _playback_buf->write_space() >= _playback_buf->capacity() / 2;
+	} else {
+		need_butler = _playback_buf->write_space() >= disk_io_chunk_frames
+			|| _capture_buf->read_space() >= disk_io_chunk_frames;
+	}
+	
+	state_lock.unlock();
+
+	_processed = false;
+
+	return need_butler;
+}
+
+void
+MidiDiskstream::set_pending_overwrite (bool yn)
+{
+	/* called from audio thread, so we can use the read ptr and playback sample as we wish */
+	
+	pending_overwrite = yn;
+
+	overwrite_frame = playback_sample;
+	//overwrite_offset = channels.front().playback_buf->get_read_ptr();
+}
+
+int
+MidiDiskstream::overwrite_existing_buffers ()
+{
+	return 0;
+}
+
+int
+MidiDiskstream::seek (nframes_t frame, bool complete_refill)
+{
+	Glib::Mutex::Lock lm (state_lock);
+	int ret = -1;
+
+	_playback_buf->reset();
+	_capture_buf->reset();
+
+	playback_sample = frame;
+	file_frame = frame;
+	_last_flush_frame = frame;
+
+	if (complete_refill) {
+		while ((ret = do_refill_with_alloc ()) > 0) ;
+	} else {
+		ret = do_refill_with_alloc ();
+	}
+
+	return ret;
+}
+
+int
+MidiDiskstream::can_internal_playback_seek (nframes_t distance)
+{
+	if (_playback_buf->read_space() < distance) {
+		return false;
+	} else {
+		return true;
+	}
+}
+
+int
+MidiDiskstream::internal_playback_seek (nframes_t distance)
+{
+	first_recordable_frame += distance;
+	playback_sample += distance;
+
+	return 0;
+}
+
+/** @a start is set to the new frame position (TIME) read up to */
+int
+MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
+{	
+	nframes_t this_read = 0;
+	bool reloop = false;
+	nframes_t loop_end = 0;
+	nframes_t loop_start = 0;
+	nframes_t loop_length = 0;
+	Location *loc = 0;
+
+	if (!reversed) {
+		/* Make the use of a Location atomic for this read operation.
+		   
+		   Note: Locations don't get deleted, so all we care about
+		   when I say "atomic" is that we are always pointing to
+		   the same one and using a start/length values obtained
+		   just once.
+		*/
+		
+		if ((loc = loop_location) != 0) {
+			loop_start = loc->start();
+			loop_end = loc->end();
+			loop_length = loop_end - loop_start;
+		}
+		
+		/* if we are looping, ensure that the first frame we read is at the correct
+		   position within the loop.
+		*/
+		
+		if (loc && start >= loop_end) {
+			//cerr << "start adjusted from " << start;
+			start = loop_start + ((start - loop_start) % loop_length);
+			//cerr << "to " << start << endl;
+		}
+		//cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
+	}
+
+	while (dur) {
+
+		/* take any loop into account. we can't read past the end of the loop. */
+
+		if (loc && (loop_end - start < dur)) {
+			this_read = loop_end - start;
+			//cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
+			reloop = true;
+		} else {
+			reloop = false;
+			this_read = dur;
+		}
+
+		if (this_read == 0) {
+			break;
+		}
+
+		this_read = min(dur,this_read);
+
+		if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
+			error << string_compose(_("MidiDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read, 
+					 start) << endmsg;
+			return -1;
+		}
+
+		_read_data_count = _playlist->read_data_count();
+		
+		if (reversed) {
+
+			cerr << "Reversed MIDI.. that's just crazy talk." << endl;
+			// Swap note ons with note offs here
+
+		} else {
+			
+			/* if we read to the end of the loop, go back to the beginning */
+			
+			if (reloop) {
+				start = loop_start;
+			} else {
+				start += this_read;
+			}
+		} 
+
+		dur -= this_read;
+	}
+
+	return 0;
+}
+
+int
+MidiDiskstream::do_refill_with_alloc ()
+{
+	return do_refill();
+}
+
+int
+MidiDiskstream::do_refill ()
+{
+	int32_t        ret = 0;
+	size_t         write_space = _playback_buf->write_space();
+
+	bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
+
+	if (write_space == 0) {
+		return 0;
+	}
+
+	/* if there are 2+ chunks of disk i/o possible for
+	   this track, let the caller know so that it can arrange
+	   for us to be called again, ASAP.
+	   */
+
+	// FIXME: using disk_io_chunk_frames as an event count, not good
+	if (_playback_buf->write_space() >= (_slaved?3:2) * disk_io_chunk_frames) {
+		ret = 1;
+	}
+
+	/* if we're running close to normal speed and there isn't enough 
+	   space to do disk_io_chunk_frames of I/O, then don't bother.  
+
+	   at higher speeds, just do it because the sync between butler
+	   and audio thread may not be good enough.
+	   */
+
+	if ((write_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
+		cerr << "No refill 1\n";
+		return 0;
+	}
+
+	/* when slaved, don't try to get too close to the read pointer. this
+	   leaves space for the buffer reversal to have something useful to
+	   work with.
+	   */
+
+	if (_slaved && write_space < (_playback_buf->capacity() / 2)) {
+		cerr << "No refill 2\n";
+		return 0;
+	}
+
+	if (reversed) {
+		cerr << "No refill 3 (reverse)\n";
+		return 0;
+	}
+
+	if (file_frame == max_frames) {
+		//cerr << "No refill 4 (EOF)\n";
+
+		/* at end: nothing to do */
+
+		return 0;
+	}
+
+#if 0
+	// or this
+	if (file_frame > max_frames - total_space) {
+
+		/* to close to the end: read what we can, and zero fill the rest */
+
+		zero_fill = total_space - (max_frames - file_frame);
+		total_space = max_frames - file_frame;
+
+	} else {
+		zero_fill = 0;
+	}
+#endif
+
+	// At this point we:
+	assert(_playback_buf->write_space() > 0); // ... have something to write to, and
+	assert(file_frame <= max_frames); // ... something to write
+
+	// So (read it, then) write it:
+	
+	nframes_t file_frame_tmp = file_frame;
+	nframes_t to_read = min(disk_io_chunk_frames, (max_frames - file_frame));
+	
+	// FIXME: read count?
+	if (read (file_frame_tmp, to_read, reversed)) {
+		ret = -1;
+		goto out;
+	}
+
+	file_frame = file_frame_tmp;
+
+out:
+
+	return ret;
+}
+
+/** Flush pending data to disk.
+ *
+ * Important note: this function will write *AT MOST* disk_io_chunk_frames
+ * of data to disk. it will never write more than that.  If it writes that
+ * much and there is more than that waiting to be written, it will return 1,
+ * otherwise 0 on success or -1 on failure.
+ * 
+ * If there is less than disk_io_chunk_frames to be written, no data will be
+ * written at all unless @a force_flush is true.
+ */
+int
+MidiDiskstream::do_flush (Session::RunContext context, bool force_flush)
+{
+	uint32_t to_write;
+	int32_t ret = 0;
+	// FIXME: I'd be lying if I said I knew what this thing was
+	//RingBufferNPT<CaptureTransition>::rw_vector transvec;
+	nframes_t total;
+
+	_write_data_count = 0;
+
+	if (_last_flush_frame > _session.transport_frame()) {
+		_last_flush_frame = _session.transport_frame();
+	}
+
+	total = _session.transport_frame() - _last_flush_frame;
+
+
+	// FIXME: put this condition back in! (removed for testing)
+	if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
+		//cerr << "MDS - no flush 1\n";
+		goto out;
+	}
+
+	/* if there are 2+ chunks of disk i/o possible for
+	   this track, let the caller know so that it can arrange
+	   for us to be called again, ASAP.
+
+	   if we are forcing a flush, then if there is* any* extra
+	   work, let the caller know.
+
+	   if we are no longer recording and there is any extra work,
+	   let the caller know too.
+	   */
+
+	if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
+		ret = 1;
+	} 
+
+	//to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
+	to_write = disk_io_chunk_frames;
+
+	assert(!destructive());
+
+	if ((!_write_source) || _write_source->write (*_capture_buf, to_write) != to_write) {
+		//cerr << "MDS - no flush 2\n";
+		error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
+		return -1;
+	} else {
+		_last_flush_frame = _session.transport_frame();
+		//cerr << "MDS - flushed\n";
+	}
+
+	//(*chan).curr_capture_cnt += to_write;
+
+out:
+	//return ret;
+	return 0;
+}
+
+void
+MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
+{
+	uint32_t buffer_position;
+	bool more_work = true;
+	int err = 0;
+	boost::shared_ptr<MidiRegion> region;
+	nframes_t total_capture;
+	MidiRegion::SourceList srcs;
+	MidiRegion::SourceList::iterator src;
+	vector<CaptureInfo*>::iterator ci;
+	bool mark_write_completed = false;
+
+	finish_capture (true);
+
+	/* butler is already stopped, but there may be work to do 
+	   to flush remaining data to disk.
+	   */
+
+	while (more_work && !err) {
+		switch (do_flush (Session::TransportContext, true)) {
+			case 0:
+				more_work = false;
+				break;
+			case 1:
+				break;
+			case -1:
+				error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
+				err++;
+		}
+	}
+
+	/* XXX is there anything we can do if err != 0 ? */
+	Glib::Mutex::Lock lm (capture_info_lock);
+
+	if (capture_info.empty()) {
+		return;
+	}
+
+	if (abort_capture) {
+
+		if (_write_source) {
+
+			_write_source->mark_for_remove ();
+			_write_source->drop_references ();
+			_write_source.reset();
+		}
+
+		/* new source set up in "out" below */
+
+	} else {
+
+		assert(_write_source);
+
+		for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+			total_capture += (*ci)->frames;
+		}
+
+		/* figure out the name for this take */
+
+		boost::shared_ptr<SMFSource> s = _write_source;
+
+		if (s) {
+
+			srcs.push_back (s);
+
+			cerr << "MidiDiskstream: updating source after capture\n";
+			s->update_header (capture_info.front()->start, when, twhen);
+
+			s->set_captured_for (_name);
+
+		}
+
+		string whole_file_region_name;
+		whole_file_region_name = region_name_from_path (_write_source->name(), true);
+		/* Register a new region with the Session that
+		   describes the entire source. Do this first
+		   so that any sub-regions will obviously be
+		   children of this one (later!)
+		   */
+		try {
+			assert(_write_source);
+			
+			boost::shared_ptr<Region> rx (RegionFactory::create (srcs, _write_source->last_capture_start_frame(), total_capture, 
+									     whole_file_region_name, 
+									     0, Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
+
+			region = boost::dynamic_pointer_cast<MidiRegion> (rx);
+			region->special_set_position (capture_info.front()->start);
+		}
+
+
+		catch (failed_constructor& err) {
+			error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
+			/* XXX what now? */
+		}
+
+		_last_capture_regions.push_back (region);
+
+		// cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
+
+		XMLNode &before = _playlist->get_state();
+		_playlist->freeze ();
+
+		for (buffer_position = _write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+
+			string region_name;
+			_session.region_name (region_name, _write_source->name(), false);
+
+			// cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
+
+			try {
+				boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
+				region = boost::dynamic_pointer_cast<MidiRegion> (rx);
+			}
+
+			catch (failed_constructor& err) {
+				error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
+				continue; /* XXX is this OK? */
+			}
+
+			_last_capture_regions.push_back (region);
+
+			// cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
+
+			i_am_the_modifier++;
+			_playlist->add_region (region, (*ci)->start);
+			i_am_the_modifier--;
+
+			buffer_position += (*ci)->frames;
+		}
+
+		_playlist->thaw ();
+		XMLNode &after = _playlist->get_state();
+		_session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
+
+		mark_write_completed = true;
+
+		reset_write_sources (mark_write_completed);
+
+	}
+
+	for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+		delete *ci;
+	}
+
+	capture_info.clear ();
+	capture_start_frame = 0;
+}
+
+void
+MidiDiskstream::finish_capture (bool rec_monitors_input)
+{
+	was_recording = false;
+	
+	if (capture_captured == 0) {
+		return;
+	}
+
+	// Why must we destroy?
+	assert(!destructive());
+
+	CaptureInfo* ci = new CaptureInfo;
+	
+	ci->start  = capture_start_frame;
+	ci->frames = capture_captured;
+	
+	/* XXX theoretical race condition here. Need atomic exchange ? 
+	   However, the circumstances when this is called right 
+	   now (either on record-disable or transport_stopped)
+	   mean that no actual race exists. I think ...
+	   We now have a capture_info_lock, but it is only to be used
+	   to synchronize in the transport_stop and the capture info
+	   accessors, so that invalidation will not occur (both non-realtime).
+	*/
+
+	// cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
+
+	capture_info.push_back (ci);
+	capture_captured = 0;
+}
+
+void
+MidiDiskstream::set_record_enabled (bool yn)
+{
+	if (!recordable() || !_session.record_enabling_legal()) {
+		return;
+	}
+
+	assert(!destructive());
+	
+	if (yn && _source_port == 0) {
+
+		/* pick up connections not initiated *from* the IO object
+		   we're associated with.
+		*/
+
+		get_input_sources ();
+	}
+
+	/* yes, i know that this not proof against race conditions, but its
+	   good enough. i think.
+	*/
+
+	if (record_enabled() != yn) {
+		if (yn) {
+			engage_record_enable ();
+		} else {
+			disengage_record_enable ();
+		}
+	}
+}
+
+void
+MidiDiskstream::engage_record_enable ()
+{
+    bool rolling = _session.transport_speed() != 0.0f;
+
+	g_atomic_int_set (&_record_enabled, 1);
+	
+	if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
+		_source_port->request_monitor_input (!(Config->get_auto_input() && rolling));
+	}
+
+	RecordEnableChanged (); /* EMIT SIGNAL */
+}
+
+void
+MidiDiskstream::disengage_record_enable ()
+{
+	g_atomic_int_set (&_record_enabled, 0);
+	if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
+		if (_source_port) {
+			_source_port->request_monitor_input (false);
+		}
+	}
+
+	RecordEnableChanged (); /* EMIT SIGNAL */
+}
+
+XMLNode&
+MidiDiskstream::get_state ()
+{
+	XMLNode* node = new XMLNode ("MidiDiskstream");
+	char buf[64];
+	LocaleGuard lg (X_("POSIX"));
+
+	snprintf (buf, sizeof(buf), "0x%x", _flags);
+	node->add_property ("flags", buf);
+
+	node->add_property ("playlist", _playlist->name());
+	
+	snprintf (buf, sizeof(buf), "%f", _visible_speed);
+	node->add_property ("speed", buf);
+
+	node->add_property("name", _name);
+	id().print(buf, sizeof(buf));
+	node->add_property("id", buf);
+
+	if (_write_source && _session.get_record_enabled()) {
+
+		XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
+		XMLNode* cs_grandchild;
+
+		cs_grandchild = new XMLNode (X_("file"));
+		cs_grandchild->add_property (X_("path"), _write_source->path());
+		cs_child->add_child_nocopy (*cs_grandchild);
+
+		/* store the location where capture will start */
+
+		Location* pi;
+
+		if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
+			snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
+		} else {
+			snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
+		}
+
+		cs_child->add_property (X_("at"), buf);
+		node->add_child_nocopy (*cs_child);
+	}
+
+	if (_extra_xml) {
+		node->add_child_copy (*_extra_xml);
+	}
+
+	return* node;
+}
+
+int
+MidiDiskstream::set_state (const XMLNode& node)
+{
+	const XMLProperty* prop;
+	XMLNodeList nlist = node.children();
+	XMLNodeIterator niter;
+	uint32_t nchans = 1;
+	XMLNode* capture_pending_node = 0;
+	LocaleGuard lg (X_("POSIX"));
+
+	in_set_state = true;
+
+ 	for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ 		/*if ((*niter)->name() == IO::state_node_name) {
+			deprecated_io_node = new XMLNode (**niter);
+ 		}*/
+ 		assert ((*niter)->name() != IO::state_node_name);
+
+		if ((*niter)->name() == X_("CapturingSources")) {
+			capture_pending_node = *niter;
+		}
+ 	}
+
+	/* prevent write sources from being created */
+	
+	in_set_state = true;
+	
+	if ((prop = node.property ("name")) != 0) {
+		_name = prop->value();
+	} 
+
+	if ((prop = node.property ("id")) != 0) {
+		_id = prop->value ();
+	}
+
+	if ((prop = node.property ("flags")) != 0) {
+		_flags = Flag (string_2_enum (prop->value(), _flags));
+	}
+
+	if ((prop = node.property ("channels")) != 0) {
+		nchans = atoi (prop->value().c_str());
+	}
+	
+	if ((prop = node.property ("playlist")) == 0) {
+		return -1;
+	}
+
+	{
+		bool had_playlist = (_playlist != 0);
+	
+		if (find_and_use_playlist (prop->value())) {
+			return -1;
+		}
+
+		if (!had_playlist) {
+			_playlist->set_orig_diskstream_id (_id);
+		}
+		
+		if (capture_pending_node) {
+			use_pending_capture_data (*capture_pending_node);
+		}
+
+	}
+
+	if ((prop = node.property ("speed")) != 0) {
+		double sp = atof (prop->value().c_str());
+
+		if (realtime_set_speed (sp, false)) {
+			non_realtime_set_speed ();
+		}
+	}
+
+	in_set_state = false;
+
+	/* make sure this is clear before we do anything else */
+
+	// FIXME?
+	//_capturing_source = 0;
+
+	/* write sources are handled when we handle the input set 
+	   up of the IO that owns this DS (::non_realtime_input_change())
+	*/
+		
+	in_set_state = false;
+
+	return 0;
+}
+
+int
+MidiDiskstream::use_new_write_source (uint32_t n)
+{
+	if (!recordable()) {
+		return 1;
+	}
+
+	assert(n == 0);
+
+	if (_write_source) {
+
+		if (SMFSource::is_empty (_write_source->path())) {
+			_write_source->mark_for_remove ();
+			_write_source.reset();
+		} else {
+			_write_source.reset();
+		}
+	}
+
+	try {
+		_write_source = boost::dynamic_pointer_cast<SMFSource>(_session.create_midi_source_for_session (*this));
+		if (!_write_source) {
+			throw failed_constructor();
+		}
+	} 
+
+	catch (failed_constructor &err) {
+		error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
+		_write_source.reset();
+		return -1;
+	}
+
+	_write_source->set_allow_remove_if_empty (true);
+
+	return 0;
+}
+
+void
+MidiDiskstream::reset_write_sources (bool mark_write_complete, bool force)
+{
+	if (!recordable()) {
+		return;
+	}
+
+	if (_write_source && mark_write_complete) {
+		_write_source->mark_streaming_write_completed ();
+	}
+
+	if (!_write_source) {
+		use_new_write_source ();
+	}
+}
+
+int
+MidiDiskstream::rename_write_sources ()
+{
+	if (_write_source != 0) {
+		_write_source->set_name (_name, destructive());
+		/* XXX what to do if this fails ? */
+	}
+	return 0;
+}
+
+void
+MidiDiskstream::set_block_size (nframes_t nframes)
+{
+}
+
+void
+MidiDiskstream::allocate_temporary_buffers ()
+{
+}
+
+void
+MidiDiskstream::monitor_input (bool yn)
+{
+	if (_source_port)
+		_source_port->request_monitor_input (yn);
+	else
+		cerr << "MidiDiskstream NO SOURCE PORT TO MONITOR\n";
+}
+
+void
+MidiDiskstream::set_align_style_from_io ()
+{
+	bool have_physical = false;
+
+	if (_io == 0) {
+		return;
+	}
+
+	get_input_sources ();
+	
+	if (_source_port && _source_port->flags() & JackPortIsPhysical) {
+		have_physical = true;
+	}
+
+	if (have_physical) {
+		set_align_style (ExistingMaterial);
+	} else {
+		set_align_style (CaptureTime);
+	}
+}
+
+
+float
+MidiDiskstream::playback_buffer_load () const
+{
+	return (float) ((double) _playback_buf->read_space()/
+			(double) _playback_buf->capacity());
+}
+
+float
+MidiDiskstream::capture_buffer_load () const
+{
+	return (float) ((double) _capture_buf->write_space()/
+			(double) _capture_buf->capacity());
+}
+
+
+int
+MidiDiskstream::use_pending_capture_data (XMLNode& node)
+{
+	return 0;
+}
+
+/** Writes playback events in the given range to dst, translating time stamps
+ * so that an event at start has time = 0
+ */
+void
+MidiDiskstream::get_playback(MidiBuffer& dst, nframes_t start, nframes_t end)
+{
+	dst.clear();
+	assert(dst.size() == 0);
+	
+	// I think this happens with reverse varispeed?  maybe?
+	if (end <= start) {
+		return;
+	}
+
+/*
+	cerr << "MIDI Diskstream pretending to read" << endl;
+
+	MidiEvent ev;
+	RawMidi data[4];
+
+	const char note = rand()%30 + 30;
+	
+	ev.buffer = data;
+	ev.time = 0;
+	ev.size = 3;
+
+	data[0] = 0x90;
+	data[1] = note;
+	data[2] = 120;
+
+	dst.push_back(ev);
+	
+	ev.buffer = data;
+	ev.time = (end - start) / 2;
+	ev.size = 3;
+
+	data[0] = 0x80;
+	data[1] = note;
+	data[2] = 64;
+*/
+	_playback_buf->read(dst, start, end);
+
+	// Translate time stamps to be relative to the start of this cycle
+	for (size_t i=0; i < dst.size(); ++i) {
+		assert(dst[i].time >= start);
+		assert(dst[i].time <= end);
+		//cerr << "Translating event stamp " << dst[i].time << " to ";
+		dst[i].time -= start;
+		//cerr << dst[i].time << endl;
+
+	}
+}
diff --git a/libs/ardour/midi_playlist.cc b/libs/ardour/midi_playlist.cc
new file mode 100644
index 0000000000..d1b2a58e82
--- /dev/null
+++ b/libs/ardour/midi_playlist.cc
@@ -0,0 +1,355 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+ 	Written by Dave Robillard, 2006
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+ 
+    This program 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 General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <cassert>
+
+#include <algorithm>
+
+#include <stdlib.h>
+
+#include <sigc++/bind.h>
+
+#include <ardour/types.h>
+#include <ardour/configuration.h>
+#include <ardour/midi_playlist.h>
+#include <ardour/midi_region.h>
+#include <ardour/session.h>
+#include <ardour/midi_ring_buffer.h>
+
+#include <pbd/error.h>
+
+#include "i18n.h"
+
+using namespace ARDOUR;
+using namespace sigc;
+using namespace std;
+
+MidiPlaylist::MidiPlaylist (Session& session, const XMLNode& node, bool hidden)
+		: Playlist (session, node, DataType::MIDI, hidden)
+{
+	const XMLProperty* prop = node.property("type");
+	assert(prop && DataType(prop->value()) == DataType::MIDI);
+
+	in_set_state = true;
+	set_state (node);
+	in_set_state = false;
+}
+
+MidiPlaylist::MidiPlaylist (Session& session, string name, bool hidden)
+		: Playlist (session, name, DataType::MIDI, hidden)
+{
+}
+
+MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, string name, bool hidden)
+		: Playlist (other, name, hidden)
+{
+	throw; // nope
+
+	/*
+	list<Region*>::const_iterator in_o  = other.regions.begin();
+	list<Region*>::iterator in_n = regions.begin();
+
+	while (in_o != other.regions.end()) {
+		MidiRegion *ar = dynamic_cast<MidiRegion *>( (*in_o) );
+
+		for (list<Crossfade *>::const_iterator xfades = other._crossfades.begin(); xfades != other._crossfades.end(); ++xfades) {
+			if ( &(*xfades)->in() == ar) {
+				// We found one! Now copy it!
+
+				list<Region*>::const_iterator out_o = other.regions.begin();
+				list<Region*>::const_iterator out_n = regions.begin();
+
+				while (out_o != other.regions.end()) {
+
+					MidiRegion *ar2 = dynamic_cast<MidiRegion *>( (*out_o) );
+
+					if ( &(*xfades)->out() == ar2) {
+						MidiRegion *in  = dynamic_cast<MidiRegion*>( (*in_n) );
+						MidiRegion *out = dynamic_cast<MidiRegion*>( (*out_n) );
+						Crossfade *new_fade = new Crossfade( *(*xfades), in, out);
+						add_crossfade(*new_fade);
+						break;
+					}
+
+					out_o++;
+					out_n++;
+				}
+				//				cerr << "HUH!? second region in the crossfade not found!" << endl;
+			}
+		}
+
+		in_o++;
+		in_n++;
+	}
+*/
+}
+
+MidiPlaylist::MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, nframes_t start, nframes_t dur, string name, bool hidden)
+		: Playlist (other, start, dur, name, hidden)
+{
+	/* this constructor does NOT notify others (session) */
+}
+
+MidiPlaylist::~MidiPlaylist ()
+{
+  	GoingAway (); /* EMIT SIGNAL */
+}
+
+struct RegionSortByLayer {
+    bool operator() (boost::shared_ptr<Region> a, boost::shared_ptr<Region> b) {
+	    return a->layer() < b->layer();
+    }
+};
+
+/** Returns the number of frames in time duration read (eg could be large when 0 events are read) */
+nframes_t
+MidiPlaylist::read (MidiRingBuffer& dst, nframes_t start,
+                     nframes_t dur, unsigned chan_n)
+{
+	/* this function is never called from a realtime thread, so
+	   its OK to block (for short intervals).
+	*/
+
+	Glib::Mutex::Lock rm (region_lock);
+
+	nframes_t ret         = 0;
+	nframes_t end         = start + dur - 1;
+	//nframes_t read_frames = 0;
+	//nframes_t skip_frames = 0;
+
+	//_read_data_count = 0;
+
+	// relevent regions overlapping start <--> end
+	vector<boost::shared_ptr<Region> > regs;
+
+	for (RegionList::iterator i = regions.begin(); i != regions.end(); ++i) {
+
+		if ((*i)->coverage (start, end) != OverlapNone) {
+			regs.push_back(*i);
+		}
+	}
+
+	RegionSortByLayer layer_cmp;
+	sort(regs.begin(), regs.end(), layer_cmp);
+
+	for (vector<boost::shared_ptr<Region> >::iterator i = regs.begin(); i != regs.end(); ++i) {
+		// FIXME: ensure time is monotonic here
+		boost::shared_ptr<MidiRegion> mr = boost::dynamic_pointer_cast<MidiRegion>(*i);
+		mr->read_at (dst, start, dur, chan_n, 0, 0);// FIXME read_frames, skip_frames);
+		ret += mr->read_data_count();
+	}
+
+	_read_data_count += ret;
+	
+	//return ret; FIXME?
+	return dur;
+}
+
+
+void
+MidiPlaylist::remove_dependents (boost::shared_ptr<Region> region)
+{
+}
+
+
+void
+MidiPlaylist::flush_notifications ()
+{
+	Playlist::flush_notifications();
+
+	if (in_flush) {
+		return;
+	}
+
+	in_flush = true;
+
+	in_flush = false;
+}
+
+void
+MidiPlaylist::refresh_dependents (boost::shared_ptr<Region> r)
+{
+}
+
+void
+MidiPlaylist::finalize_split_region (boost::shared_ptr<Region> original, boost::shared_ptr<Region> left, boost::shared_ptr<Region> right)
+{
+	throw; // I don't wanna
+	/*
+	MidiRegion *orig  = dynamic_cast<MidiRegion*>(o);
+	MidiRegion *left  = dynamic_cast<MidiRegion*>(l);
+	MidiRegion *right = dynamic_cast<MidiRegion*>(r);
+
+	for (Crossfades::iterator x = _crossfades.begin(); x != _crossfades.end();) {
+		Crossfades::iterator tmp;
+		tmp = x;
+		++tmp;
+
+		Crossfade *fade = 0;
+
+		if ((*x)->_in == orig) {
+			if (! (*x)->covers(right->position())) {
+				fade = new Crossfade( *(*x), left, (*x)->_out);
+			} else {
+				// Overlap, the crossfade is copied on the left side of the right region instead
+				fade = new Crossfade( *(*x), right, (*x)->_out);
+			}
+		}
+
+		if ((*x)->_out == orig) {
+			if (! (*x)->covers(right->position())) {
+				fade = new Crossfade( *(*x), (*x)->_in, right);
+			} else {
+				// Overlap, the crossfade is copied on the right side of the left region instead
+				fade = new Crossfade( *(*x), (*x)->_in, left);
+			}
+		}
+
+		if (fade) {
+			_crossfades.remove( (*x) );
+			add_crossfade (*fade);
+		}
+		x = tmp;
+	}*/
+}
+
+void
+MidiPlaylist::check_dependents (boost::shared_ptr<Region> r, bool norefresh)
+{
+}
+
+
+int
+MidiPlaylist::set_state (const XMLNode& node)
+{
+	if (!in_set_state) {
+		Playlist::set_state (node);
+	}
+
+	// Actually Charles, I don't much care for children
+	
+	/*
+	XMLNodeList nlist = node.children();
+
+	for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
+
+		XMLNode* const child = *niter;
+
+	}*/
+
+	return 0;
+}
+
+XMLNode&
+MidiPlaylist::state (bool full_state)
+{
+	XMLNode& node = Playlist::state (full_state);
+
+	return node;
+}
+
+void
+MidiPlaylist::dump () const
+{
+	boost::shared_ptr<Region> r;
+
+	cerr << "Playlist \"" << _name << "\" " << endl
+	<< regions.size() << " regions "
+	<< endl;
+
+	for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
+		r = *i;
+		cerr << "  " << r->name() << " @ " << r << " ["
+		<< r->start() << "+" << r->length()
+		<< "] at "
+		<< r->position()
+		<< " on layer "
+		<< r->layer ()
+		<< endl;
+	}
+}
+
+bool
+MidiPlaylist::destroy_region (boost::shared_ptr<Region> region)
+{
+	boost::shared_ptr<MidiRegion> r = boost::dynamic_pointer_cast<MidiRegion> (region);
+	bool changed = false;
+
+	if (r == 0) {
+		PBD::fatal << _("programming error: non-midi Region passed to remove_overlap in midi playlist")
+		<< endmsg;
+		/*NOTREACHED*/
+		return false;
+	}
+
+	{
+		RegionLock rlock (this);
+		RegionList::iterator i;
+		RegionList::iterator tmp;
+
+		for (i = regions.begin(); i != regions.end(); ) {
+
+			tmp = i;
+			++tmp;
+
+			if ((*i) == region) {
+				regions.erase (i);
+				changed = true;
+			}
+
+			i = tmp;
+		}
+	}
+
+
+	if (changed) {
+		/* overload this, it normally means "removed", not destroyed */
+		notify_region_removed (region);
+	}
+
+	return changed;
+}
+
+bool
+MidiPlaylist::region_changed (Change what_changed, boost::shared_ptr<Region> region)
+{
+	if (in_flush || in_set_state) {
+		return false;
+	}
+
+	// Feeling rather uninterested today, but thanks for the heads up anyway!
+	
+	Change our_interests = Change (/*MidiRegion::FadeInChanged|
+	                               MidiRegion::FadeOutChanged|
+	                               MidiRegion::FadeInActiveChanged|
+	                               MidiRegion::FadeOutActiveChanged|
+	                               MidiRegion::EnvelopeActiveChanged|
+	                               MidiRegion::ScaleAmplitudeChanged|
+	                               MidiRegion::EnvelopeChanged*/);
+	bool parent_wants_notify;
+
+	parent_wants_notify = Playlist::region_changed (what_changed, region);
+
+	if ((parent_wants_notify || (what_changed & our_interests))) {
+		notify_modified ();
+	}
+
+	return true;
+}
+
diff --git a/libs/ardour/midi_port.cc b/libs/ardour/midi_port.cc
new file mode 100644
index 0000000000..1ffd7e93bb
--- /dev/null
+++ b/libs/ardour/midi_port.cc
@@ -0,0 +1,115 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <cassert>
+#include <iostream>
+
+#include <ardour/midi_port.h>
+#include <ardour/data_type.h>
+
+using namespace ARDOUR;
+using namespace std;
+
+MidiPort::MidiPort(jack_port_t* p)
+	: Port(p)
+	, _buffer(4096) // FIXME FIXME FIXME Jack needs to tell us this
+	, _nframes_this_cycle(0)
+{
+	DataType dt(_type);
+	assert(dt == DataType::MIDI);
+
+	reset();
+
+
+}
+
+
+MidiPort::~MidiPort()
+{
+}
+
+void
+MidiPort::cycle_start (nframes_t nframes)
+{
+	_buffer.clear();
+	assert(_buffer.size() == 0);
+
+	_nframes_this_cycle = nframes;
+
+	if (_flags & JackPortIsOutput) {
+		_buffer.silence(nframes);
+		assert(_buffer.size() == 0);
+		return;
+	}
+
+	// We're an input - copy Jack events to internal buffer
+	
+	void* jack_buffer = jack_port_get_buffer(_port, nframes);
+
+	const nframes_t event_count
+		= jack_midi_get_event_count(jack_buffer);
+
+	assert(event_count < _buffer.capacity());
+
+	MidiEvent ev;
+
+	// FIXME: too slow, event struct is copied twice (here and MidiBuffer::push_back)
+	for (nframes_t i=0; i < event_count; ++i) {
+
+		// This will fail to compile if we change MidiEvent to our own class
+		jack_midi_event_get(static_cast<jack_midi_event_t*>(&ev), jack_buffer, i);
+
+		_buffer.push_back(ev);
+		// Convert note ons with velocity 0 to proper note offs
+		// FIXME: Jack MIDI should guarantee this - does it?
+		//if (ev->buffer[0] == MIDI_CMD_NOTE_ON && ev->buffer[2] == 0)
+		//	ev->buffer[0] = MIDI_CMD_NOTE_OFF;
+	}
+
+	assert(_buffer.size() == event_count);
+
+	//if (_buffer.size() > 0)
+	//	cerr << "MIDIPort got " << event_count << " events." << endl;
+}
+
+void
+MidiPort::cycle_end()
+{
+	if (_flags & JackPortIsInput) {
+		_nframes_this_cycle = 0;
+		return;
+	}
+
+	// We're an output - copy events from internal buffer to Jack buffer
+	
+	void* jack_buffer = jack_port_get_buffer(_port, _nframes_this_cycle);
+
+	const nframes_t event_count = _buffer.size();
+	
+	//if (event_count > 0)
+	//	cerr << "MIDIPort writing " << event_count << " events." << endl;
+
+	jack_midi_clear_buffer(jack_buffer);
+	for (nframes_t i=0; i < event_count; ++i) {
+		const jack_midi_event_t& ev = _buffer[i];
+		assert(ev.time < _nframes_this_cycle);
+		jack_midi_event_write(jack_buffer, ev.time, ev.buffer, ev.size);
+	}
+	
+	_nframes_this_cycle = 0;
+}
diff --git a/libs/ardour/midi_region.cc b/libs/ardour/midi_region.cc
new file mode 100644
index 0000000000..78c238233e
--- /dev/null
+++ b/libs/ardour/midi_region.cc
@@ -0,0 +1,297 @@
+/*
+    Copyright (C) 2000-2006 Paul Davis 
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    $Id: midiregion.cc 746 2006-08-02 02:44:23Z drobilla $
+*/
+
+#include <cmath>
+#include <climits>
+#include <cfloat>
+
+#include <set>
+
+#include <sigc++/bind.h>
+#include <sigc++/class_slot.h>
+
+#include <glibmm/thread.h>
+
+#include <pbd/basename.h>
+#include <pbd/xml++.h>
+
+#include <ardour/midi_region.h>
+#include <ardour/session.h>
+#include <ardour/gain.h>
+#include <ardour/dB.h>
+#include <ardour/playlist.h>
+#include <ardour/midi_source.h>
+#include <ardour/types.h>
+#include <ardour/midi_ring_buffer.h>
+
+#include "i18n.h"
+#include <locale.h>
+
+using namespace std;
+using namespace ARDOUR;
+
+/** Basic MidiRegion constructor (one channel) */
+MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, nframes_t start, nframes_t length)
+	: Region (src, start, length, PBD::basename_nosuffix(src->name()), DataType::MIDI, 0,  Region::Flag(Region::DefaultFlags|Region::External))
+{
+	assert(_name.find("/") == string::npos);
+}
+
+/* Basic MidiRegion constructor (one channel) */
+MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
+	: Region (src, start, length, name, DataType::MIDI, layer, flags)
+{
+	assert(_name.find("/") == string::npos);
+}
+
+/* Basic MidiRegion constructor (many channels) */
+MidiRegion::MidiRegion (SourceList& srcs, nframes_t start, nframes_t length, const string& name, layer_t layer, Flag flags)
+	: Region (srcs, start, length, name, DataType::MIDI, layer, flags)
+{
+	assert(_name.find("/") == string::npos);
+}
+
+
+/** Create a new MidiRegion, that is part of an existing one */
+MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
+	: Region (other, offset, length, name, layer, flags)
+{
+	assert(_name.find("/") == string::npos);
+}
+
+MidiRegion::MidiRegion (boost::shared_ptr<const MidiRegion> other)
+	: Region (other)
+{
+	assert(_name.find("/") == string::npos);
+}
+
+MidiRegion::MidiRegion (boost::shared_ptr<MidiSource> src, const XMLNode& node)
+	: Region (src, node)
+{
+	if (set_state (node)) {
+		throw failed_constructor();
+	}
+
+	assert(_name.find("/") == string::npos);
+	assert(_type == DataType::MIDI);
+}
+
+MidiRegion::MidiRegion (SourceList& srcs, const XMLNode& node)
+	: Region (srcs, node)
+{
+	if (set_state (node)) {
+		throw failed_constructor();
+	}
+
+	assert(_name.find("/") == string::npos);
+	assert(_type == DataType::MIDI);
+}
+
+MidiRegion::~MidiRegion ()
+{
+}
+
+nframes_t
+MidiRegion::read_at (MidiRingBuffer& out, nframes_t position, 
+		      nframes_t dur, 
+		      uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
+{
+	return _read_at (_sources, out, position, dur, chan_n, read_frames, skip_frames);
+}
+
+nframes_t
+MidiRegion::master_read_at (MidiRingBuffer& out, nframes_t position, 
+			     nframes_t dur, uint32_t chan_n) const
+{
+	return _read_at (_master_sources, out, position, dur, chan_n, 0, 0);
+}
+
+nframes_t
+MidiRegion::_read_at (const SourceList& srcs, MidiRingBuffer& dst, 
+		       nframes_t position, nframes_t dur, 
+		       uint32_t chan_n, nframes_t read_frames, nframes_t skip_frames) const
+{
+	// cerr << _name << "._read_at(" << position << ") - " << _position << endl;
+
+	nframes_t internal_offset = 0;
+	nframes_t src_offset      = 0;
+	nframes_t to_read         = 0;
+	
+	/* precondition: caller has verified that we cover the desired section */
+
+	assert(chan_n == 0);
+	
+	if (position < _position) {
+		internal_offset = 0;
+		src_offset = _position - position;
+		dur -= src_offset;
+	} else {
+		internal_offset = position - _position;
+		src_offset = 0;
+	}
+
+	if (internal_offset >= _length) {
+		return 0; /* read nothing */
+	}
+	
+
+	if ((to_read = min (dur, _length - internal_offset)) == 0) {
+		return 0; /* read nothing */
+	}
+
+	// FIXME: non-opaque MIDI regions not yet supported
+	assert(opaque());
+
+	if (muted()) {
+		return 0; /* read nothing */
+	}
+
+	_read_data_count = 0;
+
+	boost::shared_ptr<MidiSource> src = midi_source(chan_n);
+	if (src->read (dst, _start + internal_offset, to_read, _position) != to_read) {
+		return 0; /* "read nothing" */
+	}
+
+	_read_data_count += src->read_data_count(); // FIXME: semantics?
+
+	return to_read;
+}
+	
+XMLNode&
+MidiRegion::state (bool full)
+{
+	XMLNode& node (Region::state (full));
+	XMLNode *child;
+	char buf[64];
+	char buf2[64];
+	LocaleGuard lg (X_("POSIX"));
+	
+	snprintf (buf, sizeof (buf), "0x%x", (int) _flags);
+	node.add_property ("flags", buf);
+
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		snprintf (buf2, sizeof(buf2), "source-%d", n);
+		_sources[n]->id().print (buf, sizeof(buf));
+		node.add_property (buf2, buf);
+	}
+
+	snprintf (buf, sizeof (buf), "%u", (uint32_t) _sources.size());
+	node.add_property ("channels", buf);
+
+	child = node.add_child ("Envelope");
+
+	if ( ! full) {
+		child->add_property ("default", "yes");
+	}
+
+	if (full && _extra_xml) {
+		node.add_child_copy (*_extra_xml);
+	}
+
+	return node;
+}
+
+int
+MidiRegion::set_state (const XMLNode& node)
+{
+	const XMLNodeList& nlist = node.children();
+	const XMLProperty *prop;
+	LocaleGuard lg (X_("POSIX"));
+
+	Region::set_state (node);
+
+	if ((prop = node.property ("flags")) != 0) {
+		_flags = Flag (strtol (prop->value().c_str(), (char **) 0, 16));
+	}
+
+	/* Now find child items */
+	for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
+		
+		XMLNode *child;
+		//XMLProperty *prop;
+		
+		child = (*niter);
+		
+		/** Hello, children */
+	}
+
+	return 0;
+}
+
+void
+MidiRegion::recompute_at_end ()
+{
+	/* our length has changed
+	 * (non destructively) "chop" notes that pass the end boundary, to
+	 * prevent stuck notes.
+	 */
+}	
+
+void
+MidiRegion::recompute_at_start ()
+{
+	/* as above, but the shift was from the front
+	 * maybe bump currently active note's note-ons up so they sound here?
+	 * that could be undesireable in certain situations though.. maybe
+	 * remove the note entirely, including it's note off?  something needs to
+	 * be done to keep the played MIDI sane to avoid messing up voices of
+	 * polyhonic things etc........
+	 */
+}
+
+int
+MidiRegion::separate_by_channel (Session& session, vector<MidiRegion*>& v) const
+{
+	// Separate by MIDI channel?  bit different from audio since this is separating based
+	// on the actual contained data and destructively modifies and creates new sources..
+	
+#if 0
+	SourceList srcs;
+	string new_name;
+
+	for (SourceList::const_iterator i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+
+		srcs.clear ();
+		srcs.push_back (*i);
+
+		/* generate a new name */
+		
+		if (session.region_name (new_name, _name)) {
+			return -1;
+		}
+
+		/* create a copy with just one source */
+
+		v.push_back (new MidiRegion (srcs, _start, _length, new_name, _layer, _flags));
+	}
+#endif
+
+	// Actually, I would prefer not if that's alright
+	return -1;
+}
+
+boost::shared_ptr<MidiSource>
+MidiRegion::midi_source (uint32_t n) const
+{
+	// Guaranteed to succeed (use a static cast?)
+	return boost::dynamic_pointer_cast<MidiSource>(source(n));
+}
+
diff --git a/libs/ardour/midi_source.cc b/libs/ardour/midi_source.cc
new file mode 100644
index 0000000000..d73520134a
--- /dev/null
+++ b/libs/ardour/midi_source.cc
@@ -0,0 +1,116 @@
+/*
+    Copyright (C) 2006 Paul Davis
+	Written by Dave Robillard, 2006
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <float.h>
+#include <cerrno>
+#include <ctime>
+#include <cmath>
+#include <iomanip>
+#include <algorithm>
+
+#include <pbd/xml++.h>
+#include <pbd/pthread_utils.h>
+
+#include <ardour/midi_source.h>
+#include <ardour/midi_ring_buffer.h>
+
+#include "i18n.h"
+
+using namespace std;
+using namespace ARDOUR;
+using namespace PBD;
+
+sigc::signal<void,MidiSource *> MidiSource::MidiSourceCreated;
+
+MidiSource::MidiSource (Session& s, string name)
+	: Source (s, name, DataType::MIDI)
+{
+	_read_data_count = 0;
+	_write_data_count = 0;
+}
+
+MidiSource::MidiSource (Session& s, const XMLNode& node) 
+	: Source (s, node)
+{
+	_read_data_count = 0;
+	_write_data_count = 0;
+
+	if (set_state (node)) {
+		throw failed_constructor();
+	}
+}
+
+MidiSource::~MidiSource ()
+{
+}
+
+XMLNode&
+MidiSource::get_state ()
+{
+	XMLNode& node (Source::get_state());
+
+	if (_captured_for.length()) {
+		node.add_property ("captured-for", _captured_for);
+	}
+
+	return node;
+}
+
+int
+MidiSource::set_state (const XMLNode& node)
+{
+	const XMLProperty* prop;
+
+	Source::set_state (node);
+
+	if ((prop = node.property ("captured-for")) != 0) {
+		_captured_for = prop->value();
+	}
+
+	return 0;
+}
+
+nframes_t
+MidiSource::read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const
+{
+	Glib::Mutex::Lock lm (_lock);
+	return read_unlocked (dst, start, cnt, stamp_offset);
+}
+
+nframes_t
+MidiSource::write (MidiRingBuffer& dst, nframes_t cnt)
+{
+	Glib::Mutex::Lock lm (_lock);
+	return write_unlocked (dst, cnt);
+}
+
+bool
+MidiSource::file_changed (string path)
+{
+	struct stat stat_file;
+
+	int e1 = stat (path.c_str(), &stat_file);
+	
+	return ( !e1 );
+}
+
diff --git a/libs/ardour/midi_track.cc b/libs/ardour/midi_track.cc
new file mode 100644
index 0000000000..70638d1455
--- /dev/null
+++ b/libs/ardour/midi_track.cc
@@ -0,0 +1,639 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+	By Dave Robillard, 2006
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+#include <pbd/error.h>
+#include <sigc++/retype.h>
+#include <sigc++/retype_return.h>
+#include <sigc++/bind.h>
+
+#include <ardour/midi_track.h>
+#include <ardour/midi_diskstream.h>
+#include <ardour/session.h>
+#include <ardour/redirect.h>
+#include <ardour/midi_region.h>
+#include <ardour/midi_source.h>
+#include <ardour/route_group_specialized.h>
+#include <ardour/insert.h>
+#include <ardour/midi_playlist.h>
+#include <ardour/panner.h>
+#include <ardour/utils.h>
+#include <ardour/buffer_set.h>
+
+#include "i18n.h"
+
+using namespace std;
+using namespace ARDOUR;
+using namespace PBD;
+
+MidiTrack::MidiTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
+	: Track (sess, name, flag, mode, DataType::MIDI)
+{
+	MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0);
+
+	if (_flags & Hidden) {
+		dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden);
+	} else {
+		dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Recordable);
+	}
+
+	assert(mode != Destructive);
+
+	boost::shared_ptr<MidiDiskstream> ds (new MidiDiskstream (_session, name, dflags));
+	_session.add_diskstream (ds);
+
+	set_diskstream (boost::dynamic_pointer_cast<MidiDiskstream> (ds));
+	
+	_declickable = true;
+	_freeze_record.state = NoFreeze;
+	_saved_meter_point = _meter_point;
+	_mode = mode;
+
+	set_input_minimum(ChanCount(DataType::MIDI, 1));
+	set_input_maximum(ChanCount(DataType::MIDI, 1));
+	set_output_minimum(ChanCount(DataType::MIDI, 1));
+	set_output_maximum(ChanCount(DataType::MIDI, 1));
+}
+
+MidiTrack::MidiTrack (Session& sess, const XMLNode& node)
+	: Track (sess, node)
+{
+	_freeze_record.state = NoFreeze;
+	set_state (node);
+	_declickable = true;
+	_saved_meter_point = _meter_point;
+	
+	set_input_minimum(ChanCount(DataType::MIDI, 1));
+	set_input_maximum(ChanCount(DataType::MIDI, 1));
+	set_output_minimum(ChanCount(DataType::MIDI, 1));
+	set_output_maximum(ChanCount(DataType::MIDI, 1));
+}
+
+MidiTrack::~MidiTrack ()
+{
+}
+
+
+int
+MidiTrack::set_diskstream (boost::shared_ptr<MidiDiskstream> ds)
+{
+	_diskstream = ds;
+	_diskstream->set_io (*this);
+	_diskstream->set_destructive (_mode == Destructive);
+
+	_diskstream->set_record_enabled (false);
+	//_diskstream->monitor_input (false);
+
+	ic_connection.disconnect();
+	ic_connection = input_changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change));
+
+	DiskstreamChanged (); /* EMIT SIGNAL */
+
+	return 0;
+}	
+
+int 
+MidiTrack::use_diskstream (string name)
+{
+	boost::shared_ptr<MidiDiskstream> dstream;
+
+	if ((dstream = boost::dynamic_pointer_cast<MidiDiskstream>(_session.diskstream_by_name (name))) == 0) {
+		error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), name) << endmsg;
+		return -1;
+	}
+	
+	return set_diskstream (dstream);
+}
+
+int 
+MidiTrack::use_diskstream (const PBD::ID& id)
+{
+	boost::shared_ptr<MidiDiskstream> dstream;
+
+	if ((dstream = boost::dynamic_pointer_cast<MidiDiskstream> (_session.diskstream_by_id (id))) == 0) {
+	  	error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), id) << endmsg;
+		return -1;
+	}
+	
+	return set_diskstream (dstream);
+}
+
+boost::shared_ptr<MidiDiskstream>
+MidiTrack::midi_diskstream() const
+{
+	return boost::dynamic_pointer_cast<MidiDiskstream>(_diskstream);
+}
+
+int
+MidiTrack::set_state (const XMLNode& node)
+{
+	const XMLProperty *prop;
+	XMLNodeConstIterator iter;
+
+	if (Route::set_state (node)) {
+		return -1;
+	}
+
+	if ((prop = node.property (X_("mode"))) != 0) {
+		if (prop->value() == X_("normal")) {
+			_mode = Normal;
+		} else if (prop->value() == X_("destructive")) {
+			_mode = Destructive;
+		} else {
+			warning << string_compose ("unknown midi track mode \"%1\" seen and ignored", prop->value()) << endmsg;
+			_mode = Normal;
+		}
+	} else {
+		_mode = Normal;
+	}
+
+	if ((prop = node.property ("diskstream-id")) == 0) {
+		
+		/* some old sessions use the diskstream name rather than the ID */
+
+		if ((prop = node.property ("diskstream")) == 0) {
+			fatal << _("programming error: MidiTrack given state without diskstream!") << endmsg;
+			/*NOTREACHED*/
+			return -1;
+		}
+
+		if (use_diskstream (prop->value())) {
+			return -1;
+		}
+
+	} else {
+		
+		PBD::ID id (prop->value());
+		
+		if (use_diskstream (id)) {
+			return -1;
+		}
+	}
+
+
+	XMLNodeList nlist;
+	XMLNodeConstIterator niter;
+	XMLNode *child;
+
+	nlist = node.children();
+	for (niter = nlist.begin(); niter != nlist.end(); ++niter){
+		child = *niter;
+
+		if (child->name() == X_("remote_control")) {
+			if ((prop = child->property (X_("id"))) != 0) {
+				int32_t x;
+				sscanf (prop->value().c_str(), "%d", &x);
+				set_remote_control_id (x);
+			}
+		}
+	}
+
+	pending_state = const_cast<XMLNode*> (&node);
+
+	_session.StateReady.connect (mem_fun (*this, &MidiTrack::set_state_part_two));
+
+	return 0;
+}
+
+XMLNode& 
+MidiTrack::state(bool full_state)
+{
+	XMLNode& root (Route::state(full_state));
+	XMLNode* freeze_node;
+	char buf[64];
+
+	if (_freeze_record.playlist) {
+		XMLNode* inode;
+
+		freeze_node = new XMLNode (X_("freeze-info"));
+		freeze_node->add_property ("playlist", _freeze_record.playlist->name());
+		snprintf (buf, sizeof (buf), "%d", (int) _freeze_record.state);
+		freeze_node->add_property ("state", buf);
+
+		for (vector<FreezeRecordInsertInfo*>::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) {
+			inode = new XMLNode (X_("insert"));
+			(*i)->id.print (buf, sizeof(buf));
+			inode->add_property (X_("id"), buf);
+			inode->add_child_copy ((*i)->state);
+		
+			freeze_node->add_child_nocopy (*inode);
+		}
+
+		root.add_child_nocopy (*freeze_node);
+	}
+
+	/* Alignment: act as a proxy for the diskstream */
+	
+	XMLNode* align_node = new XMLNode (X_("alignment"));
+	switch (_diskstream->alignment_style()) {
+	case ExistingMaterial:
+		snprintf (buf, sizeof (buf), X_("existing"));
+		break;
+	case CaptureTime:
+		snprintf (buf, sizeof (buf), X_("capture"));
+		break;
+	}
+	align_node->add_property (X_("style"), buf);
+	root.add_child_nocopy (*align_node);
+
+	XMLNode* remote_control_node = new XMLNode (X_("remote_control"));
+	snprintf (buf, sizeof (buf), "%d", _remote_control_id);
+	remote_control_node->add_property (X_("id"), buf);
+	root.add_child_nocopy (*remote_control_node);
+
+	switch (_mode) {
+	case Normal:
+		root.add_property (X_("mode"), X_("normal"));
+		break;
+	case Destructive:
+		root.add_property (X_("mode"), X_("destructive"));
+		break;
+	}
+
+	/* we don't return diskstream state because we don't
+	   own the diskstream exclusively. control of the diskstream
+	   state is ceded to the Session, even if we create the
+	   diskstream.
+	*/
+
+	_diskstream->id().print (buf, sizeof(buf));
+	root.add_property ("diskstream-id", buf);
+
+	return root;
+}
+
+void
+MidiTrack::set_state_part_two ()
+{
+	XMLNode* fnode;
+	XMLProperty* prop;
+	LocaleGuard lg (X_("POSIX"));
+
+	/* This is called after all session state has been restored but before
+	   have been made ports and connections are established.
+	*/
+
+	if (pending_state == 0) {
+		return;
+	}
+
+	if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
+
+		
+		_freeze_record.have_mementos = false;
+		_freeze_record.state = Frozen;
+		
+		for (vector<FreezeRecordInsertInfo*>::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) {
+			delete *i;
+		}
+		_freeze_record.insert_info.clear ();
+		
+		if ((prop = fnode->property (X_("playlist"))) != 0) {
+			boost::shared_ptr<Playlist> pl = _session.playlist_by_name (prop->value());
+			if (pl) {
+				_freeze_record.playlist = boost::dynamic_pointer_cast<MidiPlaylist> (pl);
+			} else {
+				_freeze_record.playlist.reset();
+				_freeze_record.state = NoFreeze;
+			return;
+			}
+		}
+		
+		if ((prop = fnode->property (X_("state"))) != 0) {
+			_freeze_record.state = (FreezeState) atoi (prop->value().c_str());
+		}
+		
+		XMLNodeConstIterator citer;
+		XMLNodeList clist = fnode->children();
+		
+		for (citer = clist.begin(); citer != clist.end(); ++citer) {
+			if ((*citer)->name() != X_("insert")) {
+				continue;
+			}
+			
+			if ((prop = (*citer)->property (X_("id"))) == 0) {
+				continue;
+			}
+			
+			FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo (*((*citer)->children().front()),
+										   boost::shared_ptr<Insert>());
+			frii->id = prop->value ();
+			_freeze_record.insert_info.push_back (frii);
+		}
+	}
+
+	/* Alignment: act as a proxy for the diskstream */
+
+	if ((fnode = find_named_node (*pending_state, X_("alignment"))) != 0) {
+
+		if ((prop = fnode->property (X_("style"))) != 0) {
+			if (prop->value() == "existing") {
+				_diskstream->set_persistent_align_style (ExistingMaterial);
+			} else if (prop->value() == "capture") {
+				_diskstream->set_persistent_align_style (CaptureTime);
+			}
+		}
+	}
+	return;
+}	
+
+int 
+MidiTrack::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, 
+		     bool session_state_changing, bool can_record, bool rec_monitors_input)
+{
+	if (n_outputs().get(DataType::MIDI) == 0) {
+		//return 0;
+		throw; // FIXME
+	}
+
+	if (!_active) {
+		silence (nframes, offset);
+		//return 0; // FIXME
+	}
+
+	if (session_state_changing) {
+
+		/* XXX is this safe to do against transport state changes? */
+
+		passthru_silence (start_frame, end_frame, nframes, offset, 0, false);
+		return 0;
+	}
+
+	midi_diskstream()->check_record_status (start_frame, nframes, can_record);
+
+	bool send_silence;
+	
+	if (_have_internal_generator) {
+		/* since the instrument has no input streams,
+		   there is no reason to send any signal
+		   into the route.
+		*/
+		send_silence = true;
+	} else {
+
+		if (Config->get_auto_input()) {
+			if (Config->get_monitoring_model() == SoftwareMonitoring) {
+				send_silence = false;
+			} else {
+				send_silence = true;
+			}
+		} else {
+			if (_diskstream->record_enabled()) {
+				if (Config->get_monitoring_model() == SoftwareMonitoring) {
+					send_silence = false;
+				} else {
+					send_silence = true;
+				}
+			} else {
+				send_silence = true;
+			}
+		}
+	}
+
+	apply_gain_automation = false;
+
+	if (send_silence) {
+		
+		/* if we're sending silence, but we want the meters to show levels for the signal,
+		   meter right here.
+		*/
+		
+		if (_have_internal_generator) {
+			passthru_silence (start_frame, end_frame, nframes, offset, 0, true);
+		} else {
+			if (_meter_point == MeterInput) {
+				just_meter_input (start_frame, end_frame, nframes, offset);
+			}
+			passthru_silence (start_frame, end_frame, nframes, offset, 0, false);
+		}
+
+	} else {
+	
+		/* we're sending signal, but we may still want to meter the input. 
+		 */
+
+		passthru (start_frame, end_frame, nframes, offset, 0, (_meter_point == MeterInput));
+	}
+
+	return 0;
+}
+
+int
+MidiTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
+		  bool can_record, bool rec_monitors_input)
+{
+	int dret;
+	boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
+
+	if (n_outputs().get_total() == 0 && _redirects.empty()) {
+		return 0;
+	}
+
+	if (!_active) {
+		silence (nframes, offset);
+		return 0;
+	}
+
+	nframes_t transport_frame = _session.transport_frame();
+
+	if ((nframes = check_initial_delay (nframes, offset, transport_frame)) == 0) {
+		/* need to do this so that the diskstream sets its
+		   playback distance to zero, thus causing diskstream::commit
+		   to do nothing.
+		   */
+		return diskstream->process (transport_frame, 0, 0, can_record, rec_monitors_input);
+	} 
+
+	_silent = false;
+
+	if ((dret = diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) {
+
+		silence (nframes, offset);
+
+		return dret;
+	}
+
+	/* special condition applies */
+
+	if (_meter_point == MeterInput) {
+		just_meter_input (start_frame, end_frame, nframes, offset);
+	}
+
+	if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) {
+
+		/* not actually recording, but we want to hear the input material anyway,
+		   at least potentially (depending on monitoring options)
+		   */
+
+		passthru (start_frame, end_frame, nframes, offset, 0, true);
+
+	} else {
+		/*
+		   XXX is it true that the earlier test on n_outputs()
+		   means that we can avoid checking it again here? i think
+		   so, because changing the i/o configuration of an IO
+		   requires holding the AudioEngine lock, which we hold
+		   while in the process() tree.
+		   */
+
+
+		/* copy the diskstream data to all output buffers */
+
+		//const size_t limit = n_process_buffers().get(DataType::AUDIO);
+		BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers());
+
+		diskstream->get_playback(bufs.get_midi(0), start_frame, end_frame);
+
+		process_output_buffers (bufs, start_frame, end_frame, nframes, offset,
+				(!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput));
+	
+	}
+
+	return 0;
+}
+
+int
+MidiTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, 
+			 bool can_record, bool rec_monitors_input)
+{
+	if (n_outputs().get(DataType::MIDI) == 0 && _redirects.empty()) {
+		return 0;
+	}
+
+	if (!_active) {
+		silence (nframes, offset);
+		return 0;
+	}
+
+	_silent = true;
+	apply_gain_automation = false;
+
+	silence (nframes, offset);
+
+	return midi_diskstream()->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input);
+}
+
+void
+MidiTrack::process_output_buffers (BufferSet& bufs,
+			       nframes_t start_frame, nframes_t end_frame, 
+			       nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
+			       bool meter)
+{
+	/* There's no such thing as a MIDI bus for the time being, to avoid diverging from trunk
+	 * too much until the SoC settles down.  We'll do all the MIDI route work here for now,
+	 * but the long-term goal is to have Route::process_output_buffers handle everything */
+	
+	// Run all redirects
+	if (with_redirects) {
+		Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
+		if (rm.locked()) {
+			for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
+				(*i)->run (bufs, start_frame, end_frame, nframes, offset);
+			}
+		} 
+	}
+	
+	// Main output stage
+	if (muted()) {
+		IO::silence(nframes, offset);
+	} else {
+		deliver_output(bufs, start_frame, end_frame, nframes, offset);
+	}
+}
+
+int
+MidiTrack::set_name (string str, void *src)
+{
+	int ret;
+
+	if (record_enabled() && _session.actively_recording()) {
+		/* this messes things up if done while recording */
+		return -1;
+	}
+
+	if (_diskstream->set_name (str)) {
+		return -1;
+	}
+
+	/* save state so that the statefile fully reflects any filename changes */
+
+	if ((ret = IO::set_name (str, src)) == 0) {
+		_session.save_state ("");
+	}
+	return ret;
+}
+
+int
+MidiTrack::export_stuff (BufferSet& bufs, nframes_t nframes, nframes_t end_frame)
+{
+	return -1;
+}
+
+void
+MidiTrack::set_latency_delay (nframes_t longest_session_latency)
+{
+	Route::set_latency_delay (longest_session_latency);
+	_diskstream->set_roll_delay (_roll_delay);
+}
+
+void
+MidiTrack::bounce (InterThreadInfo& itt)
+{
+	throw;
+	//vector<MidiSource*> srcs;
+	//_session.write_one_midi_track (*this, 0, _session.current_end_frame(), false, srcs, itt);
+}
+
+
+void
+MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt)
+{
+	throw;
+	//vector<MidiSource*> srcs;
+	//_session.write_one_midi_track (*this, start, end, false, srcs, itt);
+}
+
+void
+MidiTrack::freeze (InterThreadInfo& itt)
+{
+}
+
+void
+MidiTrack::unfreeze ()
+{
+	_freeze_record.state = UnFrozen;
+	FreezeChange (); /* EMIT SIGNAL */
+}
+
+int
+MidiTrack::set_mode (TrackMode m)
+{
+	assert(_diskstream);
+
+	if (m != _mode) {
+
+		if (_diskstream->set_destructive (m == Destructive)) {
+			return -1;
+		}
+
+		_mode = m;
+		
+		TrackModeChanged (); /* EMIT SIGNAL */
+	}
+
+	return 0;
+}
diff --git a/libs/ardour/mix.cc b/libs/ardour/mix.cc
index 2d31c8ccc8..1c5d258661 100644
--- a/libs/ardour/mix.cc
+++ b/libs/ardour/mix.cc
@@ -23,6 +23,8 @@
 #include <ardour/mix.h>
 #include <stdint.h>
 
+using namespace ARDOUR;
+
 #if defined (ARCH_X86) && defined (BUILD_SSE_OPTIMIZATIONS)
 // Debug wrappers
 
@@ -80,7 +82,7 @@ debug_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t n
 
 
 float
-compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current) 
+default_compute_peak (const ARDOUR::Sample * buf, nframes_t nsamples, float current) 
 {
 	for (nframes_t i = 0; i < nsamples; ++i) {
 		current = f_max (current, fabsf (buf[i]));
@@ -90,7 +92,7 @@ compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
 }	
 
 void
-find_peaks (ARDOUR::Sample *buf, nframes_t nframes, float *min, float *max)
+default_find_peaks (const ARDOUR::Sample * buf, nframes_t nframes, float *min, float *max)
 {
 	nframes_t i;
 	float a, b;
@@ -109,14 +111,14 @@ find_peaks (ARDOUR::Sample *buf, nframes_t nframes, float *min, float *max)
 }
 
 void
-apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
+default_apply_gain_to_buffer (ARDOUR::Sample * buf, nframes_t nframes, float gain)
 {		
 	for (nframes_t i=0; i<nframes; i++)
 		buf[i] *= gain;
 }
 
 void
-mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
+default_mix_buffers_with_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain)
 {
 	for (nframes_t i = 0; i < nframes; i++) {
 		dst[i] += src[i] * gain;
@@ -124,7 +126,7 @@ mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nfram
 }
 
 void
-mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
+default_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes)
 {
 	for (nframes_t i=0; i < nframes; i++) {
 		dst[i] += src[i];
@@ -135,7 +137,7 @@ mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes
 #include <Accelerate/Accelerate.h>
 
 float
-veclib_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
+veclib_compute_peak (const ARDOUR::Sample * buf, nframes_t nsamples, float current)
 {
 	float tmpmax = 0.0f;
         vDSP_maxmgv(buf, 1, &tmpmax, nsamples);
@@ -143,26 +145,26 @@ veclib_compute_peak (ARDOUR::Sample *buf, nframes_t nsamples, float current)
 }
 
 void
-veclib_find_peaks (ARDOUR::Sample *buf, nframes_t nframes, float *min, float *max)
+veclib_find_peaks (const ARDOUR::Sample * buf, nframes_t nframes, float *min, float *max)
 {
 	vDSP_maxv (buf, 1, max, nframes);
 	vDSP_minv (buf, 1, min, nframes);
 }
 
 void
-veclib_apply_gain_to_buffer (ARDOUR::Sample *buf, nframes_t nframes, float gain)
+veclib_apply_gain_to_buffer (ARDOUR::Sample * buf, nframes_t nframes, float gain)
 {
         vDSP_vsmul(buf, 1, &gain, buf, 1, nframes);
 }
 
 void
-veclib_mix_buffers_with_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes, float gain)
+veclib_mix_buffers_with_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes, float gain)
 {
         vDSP_vsma(src, 1, &gain, dst, 1, dst, 1, nframes);
 }
 
 void
-veclib_mix_buffers_no_gain (ARDOUR::Sample *dst, ARDOUR::Sample *src, nframes_t nframes)
+veclib_mix_buffers_no_gain (ARDOUR::Sample * dst, const ARDOUR::Sample * src, nframes_t nframes)
 {
         // It seems that a vector mult only operation does not exist...
         float gain = 1.0f;
diff --git a/libs/ardour/mtc_slave.cc b/libs/ardour/mtc_slave.cc
index 3b4aaae887..0a0fbc1529 100644
--- a/libs/ardour/mtc_slave.cc
+++ b/libs/ardour/mtc_slave.cc
@@ -327,7 +327,7 @@ MTC_Slave::speed_and_position (float& speed, nframes_t& pos)
 	return true;
 }
 
-nframes_t
+ARDOUR::nframes_t
 MTC_Slave::resolution() const
 {
 	return (nframes_t) session.frames_per_smpte_frame();
diff --git a/libs/ardour/panner.cc b/libs/ardour/panner.cc
index 563d4e90d4..2690ac868d 100644
--- a/libs/ardour/panner.cc
+++ b/libs/ardour/panner.cc
@@ -17,6 +17,9 @@
 
 */
 
+#define __STDC_FORMAT_MACROS 1
+#include <inttypes.h>
+
 #include <cmath>
 #include <cerrno>
 #include <fstream>
@@ -38,7 +41,8 @@
 #include <ardour/panner.h>
 #include <ardour/utils.h>
 
-#include <ardour/mix.h>
+#include <ardour/runtime_functions.h>
+#include <ardour/buffer_set.h>
 
 #include "i18n.h"
 
@@ -240,7 +244,7 @@ BaseStereoPanner::load (istream& in, string path, uint32_t& linecnt)
 	_automation.clear ();
 
 	while (in.getline (line, sizeof (line), '\n')) {
-		jack_nframes_t when;
+		nframes_t when;
 		double value;
 
 		++linecnt;
@@ -265,8 +269,10 @@ BaseStereoPanner::load (istream& in, string path, uint32_t& linecnt)
 }
 
 void
-BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes)
+BaseStereoPanner::distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes)
 {
+	assert(obufs.count().get(DataType::AUDIO) == 2);
+
 	pan_t delta;
 	Sample* dst;
 	pan_t pan;
@@ -274,10 +280,12 @@ BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nf
 	if (_muted) {
 		return;
 	}
+	
+	Sample* const src = srcbuf.data();
 
 	/* LEFT */
 
-	dst = obufs[0];
+	dst = obufs.get_audio(0).data();
 
 	if (fabsf ((delta = (left - desired_left))) > 0.002) { // about 1 degree of arc 
 		
@@ -296,7 +304,7 @@ BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nf
 		
 		pan = left * gain_coeff;
 
-		Session::mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
+		mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
 		
 	} else {
 		
@@ -307,7 +315,7 @@ BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nf
 			
 			if (pan != 0.0f) {
 				
-				Session::mix_buffers_with_gain(dst,src,nframes,pan);
+				mix_buffers_with_gain(dst,src,nframes,pan);
 
 				/* mark that we wrote into the buffer */
 
@@ -317,7 +325,7 @@ BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nf
 			
 		} else {
 			
-			Session::mix_buffers_no_gain(dst,src,nframes);
+			mix_buffers_no_gain(dst,src,nframes);
 			
 			/* mark that we wrote into the buffer */
 			
@@ -327,7 +335,7 @@ BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nf
 
 	/* RIGHT */
 
-	dst = obufs[1];
+	dst = obufs.get_audio(1).data();
 	
 	if (fabsf ((delta = (right - desired_right))) > 0.002) { // about 1 degree of arc 
 		
@@ -346,7 +354,7 @@ BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nf
 		
 		pan = right * gain_coeff;
 		
-		Session::mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
+		mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
 		
 		/* XXX it would be nice to mark the buffer as written to */
 
@@ -359,14 +367,14 @@ BaseStereoPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nf
 			
 			if (pan != 0.0f) {
 				
-				Session::mix_buffers_with_gain(dst,src,nframes,pan);
+				mix_buffers_with_gain(dst,src,nframes,pan);
 				
 				/* XXX it would be nice to mark the buffer as written to */
 			}
 			
 		} else {
 			
-			Session::mix_buffers_no_gain(dst,src,nframes);
+			mix_buffers_no_gain(dst,src,nframes);
 			
 			/* XXX it would be nice to mark the buffer as written to */
 		}
@@ -418,19 +426,22 @@ EqualPowerStereoPanner::update ()
 }
 
 void
-EqualPowerStereoPanner::distribute_automated (Sample* src, Sample** obufs, 
+EqualPowerStereoPanner::distribute_automated (AudioBuffer& srcbuf, BufferSet& obufs, 
 					      nframes_t start, nframes_t end, nframes_t nframes,
 					      pan_t** buffers)
 {
+	assert(obufs.count().get(DataType::AUDIO) == 2);
+
 	Sample* dst;
 	pan_t* pbuf;
+	Sample* const src = srcbuf.data();
 
 	/* fetch positional data */
 
 	if (!_automation.rt_safe_get_vector (start, end, buffers[0], nframes)) {
 		/* fallback */
 		if (!_muted) {
-			distribute (src, obufs, 1.0, nframes);
+			distribute (srcbuf, obufs, 1.0, nframes);
 		}
 		return;
 	}
@@ -462,25 +473,25 @@ EqualPowerStereoPanner::distribute_automated (Sample* src, Sample** obufs,
 
 	/* LEFT */
 
-	dst = obufs[0];
+	dst = obufs.get_audio(0).data();
 	pbuf = buffers[0];
 	
 	for (nframes_t n = 0; n < nframes; ++n) {
 		dst[n] += src[n] * pbuf[n];
 	}	
 
-        /* XXX it would be nice to mark the buffer as written to */
+	/* XXX it would be nice to mark the buffer as written to */
 
 	/* RIGHT */
 
-	dst = obufs[1];
+	dst = obufs.get_audio(1).data();
 	pbuf = buffers[1];
 
 	for (nframes_t n = 0; n < nframes; ++n) {
 		dst[n] += src[n] * pbuf[n];
 	}	
 	
-        /* XXX it would be nice to mark the buffer as written to */
+	/* XXX it would be nice to mark the buffer as written to */
 }
 
 StreamPanner*
@@ -620,7 +631,7 @@ Multi2dPanner::update ()
 }
 
 void
-Multi2dPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nframes_t nframes)
+Multi2dPanner::distribute (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_coeff, nframes_t nframes)
 {
 	Sample* dst;
 	pan_t pan;
@@ -630,11 +641,13 @@ Multi2dPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nfram
 	if (_muted) {
 		return;
 	}
+	
+	Sample* const src = srcbuf.data();
 
 
 	for (n = 0, o = parent.outputs.begin(); o != parent.outputs.end(); ++o, ++n) {
 
-		dst = obufs[n];
+		dst = obufs.get_audio(n).data();
 	
 #ifdef CAN_INTERP
 		if (fabsf ((delta = (left_interp - desired_left))) > 0.002) { // about 1 degree of arc 
@@ -653,7 +666,7 @@ Multi2dPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nfram
 			}
 			
 			pan = left * gain_coeff;
-			Session::mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
+			mix_buffers_with_gain(dst+n,src+n,nframes-n,pan);
 			
 		} else {
 
@@ -663,10 +676,10 @@ Multi2dPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nfram
 			if ((pan *= gain_coeff) != 1.0f) {
 				
 				if (pan != 0.0f) {
-					Session::mix_buffers_with_gain(dst,src,nframes,pan);
+					mix_buffers_with_gain(dst,src,nframes,pan);
 				} 
 			} else {
-					Session::mix_buffers_no_gain(dst,src,nframes);
+					mix_buffers_no_gain(dst,src,nframes);
 			}
 #endif
 #ifdef CAN_INTERP
@@ -678,7 +691,7 @@ Multi2dPanner::distribute (Sample* src, Sample** obufs, gain_t gain_coeff, nfram
 }
 
 void
-Multi2dPanner::distribute_automated (Sample* src, Sample** obufs, 
+Multi2dPanner::distribute_automated (AudioBuffer& src, BufferSet& obufs, 
 				     nframes_t start, nframes_t end, nframes_t nframes,
 				     pan_t** buffers)
 {
@@ -1319,6 +1332,134 @@ Panner::set_position (float xpos, float ypos, float zpos, StreamPanner& orig)
 	}
 }
 
+void
+Panner::distribute_no_automation (BufferSet& inbufs, BufferSet& outbufs, nframes_t nframes, nframes_t offset, gain_t gain_coeff)
+{
+	if (outbufs.count().get(DataType::AUDIO) == 0) {
+		// Don't want to lose audio...
+		assert(inbufs.count().get(DataType::AUDIO) == 0);
+		return;
+	}
+
+	// We shouldn't be called in the first place...
+	assert(!bypassed());
+	assert(!empty());
+
+	
+	if (outbufs.count().get(DataType::AUDIO) == 1) {
+
+		AudioBuffer& dst = outbufs.get_audio(0);
+
+		if (gain_coeff == 0.0f) {
+
+			/* only one output, and gain was zero, so make it silent */
+
+			dst.silence(offset);
+			
+		} else if (gain_coeff == 1.0f){
+
+			/* mix all buffers into the output */
+
+			// copy the first
+			dst.read_from(inbufs.get_audio(0), nframes, offset);
+			
+			// accumulate starting with the second
+			BufferSet::audio_iterator i = inbufs.audio_begin();
+			for (++i; i != inbufs.audio_end(); ++i) {
+				dst.accumulate_from(*i, nframes, offset);
+			}
+
+		} else {
+
+			/* mix all buffers into the output, scaling them all by the gain */
+
+			// copy the first
+			dst.read_from(inbufs.get_audio(0), nframes, offset);
+			
+			// accumulate (with gain) starting with the second
+			BufferSet::audio_iterator i = inbufs.audio_begin();
+			for (++i; i != inbufs.audio_end(); ++i) {
+				dst.accumulate_with_gain_from(*i, nframes, offset, gain_coeff);
+			}
+
+		}
+
+		return;
+	}
+	
+	/* the terrible silence ... */
+	for (BufferSet::audio_iterator i = outbufs.audio_begin(); i != outbufs.audio_end(); ++i) {
+		i->silence(nframes, offset);
+	}
+
+	BufferSet::audio_iterator i = inbufs.audio_begin();
+
+	for (iterator pan = begin(); pan != end() && i != inbufs.audio_end(); ++pan, ++i) {
+		(*pan)->distribute (*i, outbufs, gain_coeff, nframes);
+	}
+}
+
+void
+Panner::distribute (BufferSet& inbufs, BufferSet& outbufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
+{	
+	if (outbufs.count().get(DataType::AUDIO) == 0) {
+		// Failing to deliver audio we were asked to deliver is a bug
+		assert(inbufs.count().get(DataType::AUDIO) == 0);
+		return;
+	}
+
+	// We shouldn't be called in the first place...
+	assert(!bypassed());
+	assert(!empty());
+
+	// If we shouldn't play automation defer to distribute_no_automation
+	if ( !( automation_state() & Play ||
+			 ((automation_state() & Touch) && !touching()) ) ) {
+
+		// Speed quietning
+		gain_t gain_coeff = 1.0;
+		if (fabsf(_session.transport_speed()) > 1.5f) {
+			gain_coeff = speed_quietning;
+		}
+
+		distribute_no_automation(inbufs, outbufs, nframes, offset, gain_coeff);
+		return;
+	}
+
+	// Otherwise.. let the automation flow, baby
+	
+	if (outbufs.count().get(DataType::AUDIO) == 1) {
+
+		AudioBuffer& dst = outbufs.get_audio(0);
+
+		// FIXME: apply gain automation?
+
+		// copy the first
+		dst.read_from(inbufs.get_audio(0), nframes, offset);
+
+		// accumulate starting with the second
+		BufferSet::audio_iterator i = inbufs.audio_begin();
+		for (++i; i != inbufs.audio_end(); ++i) {
+			dst.accumulate_from(*i, nframes, offset);
+		}
+
+		return;
+	}
+
+	// More than 1 output, we should have 1 panner for each input
+	assert(size() == inbufs.count().get(DataType::AUDIO));
+	
+	/* the terrible silence ... */
+	for (BufferSet::audio_iterator i = outbufs.audio_begin(); i != outbufs.audio_end(); ++i) {
+		i->silence(nframes, offset);
+	}
+
+	BufferSet::audio_iterator i = inbufs.audio_begin();
+	for (iterator pan = begin(); pan != end(); ++pan, ++i) {
+		(*pan)->distribute_automated (*i, outbufs, start_frame, end_frame, nframes, _session.pan_automation_buffer());
+	}
+}
+
 /* old school automation handling */
 
 void
diff --git a/libs/ardour/playlist.cc b/libs/ardour/playlist.cc
index 807bcd23ca..de6d58dbd7 100644
--- a/libs/ardour/playlist.cc
+++ b/libs/ardour/playlist.cc
@@ -70,8 +70,9 @@ struct RegionSortByLastLayerOp {
     }
 };
 
-Playlist::Playlist (Session& sess, string nom, bool hide)
+Playlist::Playlist (Session& sess, string nom, DataType type, bool hide)
 	: _session (sess)
+	, _type(type)
 {
 	init (hide);
 	first_set_state = false;
@@ -79,9 +80,13 @@ Playlist::Playlist (Session& sess, string nom, bool hide)
 	
 }
 
-Playlist::Playlist (Session& sess, const XMLNode& node, bool hide)
+Playlist::Playlist (Session& sess, const XMLNode& node, DataType type, bool hide)
 	: _session (sess)
+	, _type(type)
 {
+	const XMLProperty* prop = node.property("type");
+	assert(!prop || DataType(prop->value()) == _type);
+
 	init (hide);
 	_name = "unnamed"; /* reset by set_state */
 
@@ -89,7 +94,7 @@ Playlist::Playlist (Session& sess, const XMLNode& node, bool hide)
 }
 
 Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, bool hide)
-	: _name (namestr), _session (other->_session), _orig_diskstream_id(other->_orig_diskstream_id)
+	: _name (namestr), _session (other->_session), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
 {
 	init (hide);
 
@@ -121,7 +126,7 @@ Playlist::Playlist (boost::shared_ptr<const Playlist> other, string namestr, boo
 }
 
 Playlist::Playlist (boost::shared_ptr<const Playlist> other, nframes_t start, nframes_t cnt, string str, bool hide)
-	: _name (str), _session (other->_session), _orig_diskstream_id(other->_orig_diskstream_id)
+	: _name (str), _session (other->_session), _type(other->_type), _orig_diskstream_id(other->_orig_diskstream_id)
 {
 	RegionLock rlock2 (const_cast<Playlist*> (other.get()));
 
@@ -243,12 +248,14 @@ Playlist::init (bool hide)
 
 Playlist::Playlist (const Playlist& pl)
 	: _session (pl._session)
+	, _type(pl.data_type())
 {
 	fatal << _("playlist const copy constructor called") << endmsg;
 }
 
 Playlist::Playlist (Playlist& pl)
 	: _session (pl._session)
+	, _type(pl.data_type())
 {
 	fatal << _("playlist non-const copy constructor called") << endmsg;
 }
@@ -1445,6 +1452,7 @@ Playlist::state (bool full_state)
 	char buf[64];
 	
 	node->add_property (X_("name"), _name);
+	node->add_property (X_("type"), _type.to_string());
 
 	_orig_diskstream_id.print (buf, sizeof (buf));
 	node->add_property (X_("orig_diskstream_id"), buf);
@@ -1485,7 +1493,7 @@ Playlist::get_maximum_extent () const
 	return _get_maximum_extent ();
 }
 
-nframes_t
+ARDOUR::nframes_t
 Playlist::_get_maximum_extent () const
 {
 	RegionList::const_iterator i;
diff --git a/libs/ardour/playlist_factory.cc b/libs/ardour/playlist_factory.cc
index 9cbdba0c79..a801bae76c 100644
--- a/libs/ardour/playlist_factory.cc
+++ b/libs/ardour/playlist_factory.cc
@@ -21,6 +21,7 @@
 
 #include <ardour/playlist.h>
 #include <ardour/audioplaylist.h>
+#include <ardour/midi_playlist.h>
 #include <ardour/playlist_factory.h>
 
 #include "i18n.h"
@@ -33,26 +34,34 @@ sigc::signal<void,boost::shared_ptr<Playlist> > PlaylistFactory::PlaylistCreated
 boost::shared_ptr<Playlist> 
 PlaylistFactory::create (Session& s, const XMLNode& node, bool hidden) 
 {
+	const XMLProperty* type = node.property("type");
+
 	boost::shared_ptr<Playlist> pl;
 
-	pl = boost::shared_ptr<Playlist> (new AudioPlaylist (s, node, hidden));
+	if ( !type || type->value() == "audio" )
+		pl = boost::shared_ptr<Playlist> (new AudioPlaylist (s, node, hidden));
+	else if ( type->value() == "midi" )
+		pl = boost::shared_ptr<Playlist> (new MidiPlaylist (s, node, hidden));
 
 	pl->set_region_ownership ();
 
-	if (!hidden) {
+	if (pl && !hidden) {
 		PlaylistCreated (pl);
 	}
 	return pl;
 }
 
 boost::shared_ptr<Playlist> 
-PlaylistFactory::create (Session& s, string name, bool hidden) 
+PlaylistFactory::create (DataType type, Session& s, string name, bool hidden) 
 {
 	boost::shared_ptr<Playlist> pl;
 
-	pl = boost::shared_ptr<Playlist> (new AudioPlaylist (s, name, hidden));
+	if (type == DataType::AUDIO)
+		pl = boost::shared_ptr<Playlist> (new AudioPlaylist (s, name, hidden));
+	else if (type == DataType::MIDI)
+		pl = boost::shared_ptr<Playlist> (new MidiPlaylist (s, name, hidden));
 
-	if (!hidden) {
+	if (pl && !hidden) {
 		PlaylistCreated (pl);
 	}
 
@@ -64,13 +73,17 @@ PlaylistFactory::create (boost::shared_ptr<const Playlist> old, string name, boo
 {
 	boost::shared_ptr<Playlist> pl;
 	boost::shared_ptr<const AudioPlaylist> apl;
+	boost::shared_ptr<const MidiPlaylist> mpl;
 
 	if ((apl = boost::dynamic_pointer_cast<const AudioPlaylist> (old)) != 0) {
 		pl = boost::shared_ptr<Playlist> (new AudioPlaylist (apl, name, hidden));
 		pl->set_region_ownership ();
+	} else if ((mpl = boost::dynamic_pointer_cast<const MidiPlaylist> (old)) != 0) {
+		pl = boost::shared_ptr<Playlist> (new MidiPlaylist (mpl, name, hidden));
+		pl->set_region_ownership ();
 	}
 
-	if (!hidden) {
+	if (pl && !hidden) {
 		PlaylistCreated (pl);
 	}
 
@@ -82,10 +95,14 @@ PlaylistFactory::create (boost::shared_ptr<const Playlist> old, nframes_t start,
 {
 	boost::shared_ptr<Playlist> pl;
 	boost::shared_ptr<const AudioPlaylist> apl;
+	boost::shared_ptr<const MidiPlaylist> mpl;
 	
 	if ((apl = boost::dynamic_pointer_cast<const AudioPlaylist> (old)) != 0) {
 		pl = boost::shared_ptr<Playlist> (new AudioPlaylist (apl, start, cnt, name, hidden));
 		pl->set_region_ownership ();
+	} else if ((mpl = boost::dynamic_pointer_cast<const MidiPlaylist> (old)) != 0) {
+		pl = boost::shared_ptr<Playlist> (new MidiPlaylist (mpl, start, cnt, name, hidden));
+		pl->set_region_ownership ();
 	}
 
 	/* this factory method does NOT notify others */
diff --git a/libs/ardour/plugin_manager.cc b/libs/ardour/plugin_manager.cc
index 5fa04c41f1..9af7ad0451 100644
--- a/libs/ardour/plugin_manager.cc
+++ b/libs/ardour/plugin_manager.cc
@@ -17,6 +17,9 @@
 
 */
 
+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+
 #include <sys/types.h>
 #include <cstdio>
 #include <lrdf.h>
diff --git a/libs/ardour/port.cc b/libs/ardour/port.cc
index 4b0399702a..d9c93c250b 100644
--- a/libs/ardour/port.cc
+++ b/libs/ardour/port.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2002 Paul Davis 
+    Copyright (C) 2002-2006 Paul Davis 
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -17,16 +17,15 @@
 
 */
 
-#include "ardour/port.h"
+#include <ardour/port.h>
 
 using namespace ARDOUR;
 using namespace std;
 
-nframes_t Port::_short_over_length = 2;
-nframes_t Port::_long_over_length = 10;
-
 Port::Port (jack_port_t *p) 
 	: _port (p)
+	, _metering(0)
+	, _last_monitor(false)
 {
 	if (_port == 0) {
 		throw failed_constructor();
@@ -42,13 +41,7 @@ Port::Port (jack_port_t *p)
 void
 Port::reset ()
 {
-	reset_buffer ();
-	
 	_last_monitor = false;
-	_silent = false;
-	_metering = 0;
-	
-	reset_meters ();
 }
 
 int 
diff --git a/libs/ardour/port_set.cc b/libs/ardour/port_set.cc
new file mode 100644
index 0000000000..388162359b
--- /dev/null
+++ b/libs/ardour/port_set.cc
@@ -0,0 +1,129 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+    
+    This program is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation; either version 2 of the License, or (at your option)
+    any later version.
+    
+    This program 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 General Public License
+    for more details.
+    
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <ardour/port_set.h>
+
+namespace ARDOUR {
+
+PortSet::PortSet()
+{
+	for (size_t i=0; i < DataType::num_types; ++i)
+		_ports.push_back( PortVec() );
+}
+
+static bool sort_ports_by_name (Port* a, Port* b)
+{
+	return (a->name() < b->name());
+}
+
+void
+PortSet::add(Port* port)
+{
+	const size_t list_index = port->type().to_index();
+	assert(list_index < _ports.size());
+	
+	PortVec& v = _ports[list_index];
+	
+	v.push_back(port);
+	sort(v.begin(), v.end(), sort_ports_by_name);
+
+	_count.set(port->type(), _count.get(port->type()) + 1);
+
+	assert(_count.get(port->type()) == _ports[port->type().to_index()].size());
+}
+
+bool
+PortSet::remove(Port* port)
+{
+	for (std::vector<PortVec>::iterator l = _ports.begin(); l != _ports.end(); ++l) {
+		PortVec::iterator i = find(l->begin(), l->end(), port);
+		if (i != l->end()) {
+			l->erase(i);
+			_count.set(port->type(), _count.get(port->type()) - 1);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/** Get the total number of ports (of all types) in the PortSet
+ */
+size_t
+PortSet::num_ports() const
+{
+	size_t ret = 0;
+
+	for (std::vector<PortVec>::const_iterator l = _ports.begin(); l != _ports.end(); ++l)
+		ret += (*l).size();
+
+	return ret;
+}
+
+bool
+PortSet::contains(const Port* port) const
+{
+	for (std::vector<PortVec>::const_iterator l = _ports.begin(); l != _ports.end(); ++l)
+		if (find((*l).begin(), (*l).end(), port) != (*l).end())
+			return true;
+
+	return false;
+}
+
+Port*
+PortSet::port(size_t n) const
+{
+	// This is awesome.  Awesomely slow.
+	
+	size_t size_so_far = 0;
+
+	for (std::vector<PortVec>::const_iterator l = _ports.begin(); l != _ports.end(); ++l) {
+		if (n < size_so_far + (*l).size())
+			return (*l)[n - size_so_far];
+		else
+			size_so_far += (*l).size();
+	}
+
+	return NULL; // n out of range
+}
+
+Port*
+PortSet::port(DataType type, size_t n) const
+{
+	if (type == DataType::NIL) {
+		return port(n);
+	} else {
+		const PortVec& v = _ports[type.to_index()];
+		assert(n < v.size());
+		return v[n];
+	}
+}
+
+AudioPort*
+PortSet::nth_audio_port(size_t n) const
+{
+	return dynamic_cast<AudioPort*>(port(DataType::AUDIO, n));
+}
+
+MidiPort*
+PortSet::nth_midi_port(size_t n) const
+{
+	return dynamic_cast<MidiPort*>(port(DataType::MIDI, n));
+}
+
+} // namepace ARDOUR
diff --git a/libs/ardour/redirect.cc b/libs/ardour/redirect.cc
index 045faf6ebf..ba895f6447 100644
--- a/libs/ardour/redirect.cc
+++ b/libs/ardour/redirect.cc
@@ -45,8 +45,8 @@ const string Redirect::state_node_name = "Redirect";
 sigc::signal<void,Redirect*> Redirect::RedirectCreated;
 
 Redirect::Redirect (Session& s, const string& name, Placement p,
-
-		    int input_min, int input_max, int output_min, int output_max)
+                    int input_min, int input_max,
+                    int output_min, int output_max)
 	: IO (s, name, input_min, input_max, output_min, output_max)
 {
 	_placement = p;
@@ -113,7 +113,7 @@ Redirect::set_placement (Placement p, void *src)
 
 int
 Redirect::set_automation_state (const XMLNode& node)
-{
+{	
 	Glib::Mutex::Lock lm (_automation_lock);
 
 	parameter_automation.clear ();
diff --git a/libs/ardour/region.cc b/libs/ardour/region.cc
index 2b11bcc3df..e5125d8629 100644
--- a/libs/ardour/region.cc
+++ b/libs/ardour/region.cc
@@ -32,6 +32,7 @@
 #include <ardour/region.h>
 #include <ardour/playlist.h>
 #include <ardour/session.h>
+#include <ardour/source.h>
 #include <ardour/region_factory.h>
 
 #include "i18n.h"
@@ -48,58 +49,121 @@ Change Region::LockChanged       = ARDOUR::new_change ();
 Change Region::LayerChanged      = ARDOUR::new_change ();
 Change Region::HiddenChanged     = ARDOUR::new_change ();
 
-Region::Region (nframes_t start, nframes_t length, const string& name, layer_t layer, Region::Flag flags)
+/** Basic Region constructor (single source) */
+Region::Region (boost::shared_ptr<Source> src, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
+	: _name(name)
+	, _type(type)
+	, _flags(flags)
+	, _start(start) 
+	, _length(length) 
+	, _position(0) 
+	, _sync_position(_start)
+	, _layer(layer)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _read_data_count(0)
+	, _pending_changed(Change (0))
+	, _last_layer_op(0)
 {
-	/* basic Region constructor */
+	_sources.push_back (src);
+	_master_sources.push_back (src);
+	src->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), src));
 
-	_flags = flags;
-	_read_data_count = 0;
-	_frozen = 0;
-	pending_changed = Change (0);
+	assert(_sources.size() > 0);
+}
 
-	_name = name;
-	_start = start; 
-	_sync_position = _start;
-	_length = length; 
-	_position = 0; 
-	_layer = layer;
-	_read_data_count = 0;
-	_first_edit = EditChangesNothing;
-	_last_layer_op = 0;
+/** Basic Region constructor (many sources) */
+Region::Region (SourceList& srcs, nframes_t start, nframes_t length, const string& name, DataType type, layer_t layer, Region::Flag flags)
+	: _name(name)
+	, _type(type)
+	, _flags(flags)
+	, _start(start) 
+	, _length(length) 
+	, _position(0) 
+	, _sync_position(_start)
+	, _layer(layer)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _read_data_count(0)
+	, _pending_changed(Change (0))
+	, _last_layer_op(0)
+{
+	
+	set<boost::shared_ptr<Source> > unique_srcs;
+
+	for (SourceList::iterator i=srcs.begin(); i != srcs.end(); ++i) {
+		_sources.push_back (*i);
+		(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		unique_srcs.insert (*i);
+	}
+
+	for (SourceList::iterator i = srcs.begin(); i != srcs.end(); ++i) {
+		_master_sources.push_back (*i);
+		if (unique_srcs.find (*i) == unique_srcs.end()) {
+			(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		}
+	}
+	
+	assert(_sources.size() > 0);
 }
 
+/** Create a new Region from part of an existing one */
 Region::Region (boost::shared_ptr<const Region> other, nframes_t offset, nframes_t length, const string& name, layer_t layer, Flag flags)
+	: _name(name)
+	, _type(other->data_type())
+	, _flags(Flag(flags & ~(Locked|WholeFile|Hidden)))
+	, _start(other->_start + offset) 
+	, _length(length) 
+	, _position(0) 
+	, _sync_position(_start)
+	, _layer(layer)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _read_data_count(0)
+	, _pending_changed(Change (0))
+	, _last_layer_op(0)
 {
-	/* create a new Region from part of an existing one */
+	if (other->_sync_position < offset)
+		_sync_position = other->_sync_position;
 
-	_frozen = 0;
-	pending_changed = Change (0);
-	_read_data_count = 0;
+	set<boost::shared_ptr<Source> > unique_srcs;
 
-	_start = other->_start + offset; 
+	for (SourceList::const_iterator i= other->_sources.begin(); i != other->_sources.end(); ++i) {
+		_sources.push_back (*i);
+		(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		unique_srcs.insert (*i);
+	}
+	
 	if (other->_sync_position < offset) {
 		_sync_position = other->_sync_position;
-	} else {
-		_sync_position = _start;
 	}
-	_length = length; 
-	_name = name;
-	_position = 0; 
-	_layer = layer; 
-	_flags = Flag (flags & ~(Locked|WholeFile|Hidden));
-	_first_edit = EditChangesNothing;
-	_last_layer_op = 0;
+
+	for (SourceList::const_iterator i = other->_master_sources.begin(); i != other->_master_sources.end(); ++i) {
+		if (unique_srcs.find (*i) == unique_srcs.end()) {
+			(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		}
+		_master_sources.push_back (*i);
+	}
+	
+	assert(_sources.size() > 0);
 }
 
+/** Pure copy constructor */
 Region::Region (boost::shared_ptr<const Region> other)
+	: _name(other->_name)
+	, _type(other->data_type())
+	, _flags(Flag(other->_flags & ~Locked))
+	, _start(other->_start) 
+	, _length(other->_length) 
+	, _position(other->_position) 
+	, _sync_position(other->_sync_position)
+	, _layer(other->_layer)
+	, _first_edit(EditChangesID)
+	, _frozen(0)
+	, _read_data_count(0)
+	, _pending_changed(Change(0))
+	, _last_layer_op(other->_last_layer_op)
 {
-	/* Pure copy constructor */
-
-	_frozen = 0;
-	pending_changed = Change (0);
-	_read_data_count = 0;
-
-	_first_edit = EditChangesID;
 	other->_first_edit = EditChangesName;
 
 	if (other->_extra_xml) {
@@ -108,44 +172,133 @@ Region::Region (boost::shared_ptr<const Region> other)
 		_extra_xml = 0;
 	}
 
-	_start = other->_start;
-	_sync_position = other->_sync_position;
-	_length = other->_length; 
-	_name = other->_name;
-	_position = other->_position; 
-	_layer = other->_layer; 
-	_flags = Flag (other->_flags & ~Locked);
-	_last_layer_op = other->_last_layer_op;
-}
-
-Region::Region (const XMLNode& node)
-{
-	_frozen = 0;
-	pending_changed = Change (0);
-	_read_data_count = 0;
-	_start = 0; 
-	_sync_position = _start;
-	_length = 0;
-	_name = X_("error: XML did not reset this");
-	_position = 0; 
-	_layer = 0;
-	_flags = Flag (0);
-	_first_edit = EditChangesNothing;
+	set<boost::shared_ptr<Source> > unique_srcs;
+
+	for (SourceList::const_iterator i = other->_sources.begin(); i != other->_sources.end(); ++i) {
+		_sources.push_back (*i);
+		(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		unique_srcs.insert (*i);
+	}
+
+	for (SourceList::const_iterator i = other->_master_sources.begin(); i != other->_master_sources.end(); ++i) {
+		_master_sources.push_back (*i);
+		if (unique_srcs.find (*i) == unique_srcs.end()) {
+			(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		}
+	}
+	
+	assert(_sources.size() > 0);
+}
+
+Region::Region (SourceList& srcs, const XMLNode& node)
+	: _name(X_("error: XML did not reset this"))
+	, _type(DataType::NIL) // to be loaded from XML
+	, _flags(Flag(0))
+	, _start(0) 
+	, _length(0) 
+	, _position(0) 
+	, _sync_position(_start)
+	, _layer(0)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _read_data_count(0)
+	, _pending_changed(Change(0))
+	, _last_layer_op(0)
+{
+	set<boost::shared_ptr<Source> > unique_srcs;
+
+	for (SourceList::iterator i=srcs.begin(); i != srcs.end(); ++i) {
+		_sources.push_back (*i);
+		(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		unique_srcs.insert (*i);
+	}
+
+	for (SourceList::iterator i = srcs.begin(); i != srcs.end(); ++i) {
+		_master_sources.push_back (*i);
+		if (unique_srcs.find (*i) == unique_srcs.end()) {
+			(*i)->GoingAway.connect (bind (mem_fun (*this, &Region::source_deleted), (*i)));
+		}
+	}
+
+	if (set_state (node)) {
+		throw failed_constructor();
+	}
+
+	assert(_type != DataType::NIL);
+	assert(_sources.size() > 0);
+}
+
+Region::Region (boost::shared_ptr<Source> src, const XMLNode& node)
+	: _name(X_("error: XML did not reset this"))
+	, _type(DataType::NIL)
+	, _flags(Flag(0))
+	, _start(0) 
+	, _length(0) 
+	, _position(0) 
+	, _sync_position(_start)
+	, _layer(0)
+	, _first_edit(EditChangesNothing)
+	, _frozen(0)
+	, _read_data_count(0)
+	, _pending_changed(Change(0))
+	, _last_layer_op(0)
+{
+	_sources.push_back (src);
+
 
 	if (set_state (node)) {
 		throw failed_constructor();
 	}
+	
+	assert(_type != DataType::NIL);
+	assert(_sources.size() > 0);
 }
 
 Region::~Region ()
 {
-	/* derived classes must call notify_callbacks() and then emit GoingAway */
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (pl) {
+		for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+			(*i)->remove_playlist (pl);
+		}
+	}
+	
+	notify_callbacks ();
+	GoingAway (); /* EMIT SIGNAL */
 }
 
 void
-Region::set_playlist (boost::weak_ptr<Playlist> pl)
+Region::set_playlist (boost::weak_ptr<Playlist> wpl)
 {
+	boost::shared_ptr<Playlist> old_playlist = (_playlist.lock());
+
+	boost::shared_ptr<Playlist> pl (wpl.lock());
+
+	if (old_playlist == pl) {
+		return;
+	}
+
 	_playlist = pl;
+
+	if (pl) {
+		if (old_playlist) {
+			for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+				(*i)->remove_playlist (_playlist);	
+				(*i)->add_playlist (pl);
+			}
+		} else {
+			for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+				(*i)->add_playlist (pl);
+			}
+		}
+	} else {
+		if (old_playlist) {
+			for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
+				(*i)->remove_playlist (old_playlist);
+			}
+		}
+	}
 }
 
 void
@@ -742,6 +895,7 @@ Region::state (bool full_state)
 	_id.print (buf, sizeof (buf));
 	node->add_property ("id", buf);
 	node->add_property ("name", _name);
+	node->add_property ("type", _type.to_string());
 	snprintf (buf, sizeof (buf), "%u", _start);
 	node->add_property ("start", buf);
 	snprintf (buf, sizeof (buf), "%u", _length);
@@ -800,6 +954,12 @@ Region::set_live_state (const XMLNode& node, Change& what_changed, bool send)
 	}
 
 	_name = prop->value();
+	
+	if ((prop = node.property ("type")) == 0) {
+		_type = DataType::AUDIO;
+	} else {
+		_type = DataType(prop->value());
+	}
 
 	if ((prop = node.property ("start")) != 0) {
 		sscanf (prop->value().c_str(), "%" PRIu32, &val);
@@ -914,15 +1074,15 @@ Region::thaw (const string& why)
 	Change what_changed = Change (0);
 
 	{
-		Glib::Mutex::Lock lm (lock);
+		Glib::Mutex::Lock lm (_lock);
 
 		if (_frozen && --_frozen > 0) {
 			return;
 		}
 
-		if (pending_changed) {
-			what_changed = pending_changed;
-			pending_changed = Change (0);
+		if (_pending_changed) {
+			what_changed = _pending_changed;
+			_pending_changed = Change (0);
 		}
 	}
 
@@ -944,9 +1104,9 @@ void
 Region::send_change (Change what_changed)
 {
 	{
-		Glib::Mutex::Lock lm (lock);
+		Glib::Mutex::Lock lm (_lock);
 		if (_frozen) {
-			pending_changed = Change (pending_changed|what_changed);
+			_pending_changed = Change (_pending_changed|what_changed);
 			return;
 		} 
 	}
@@ -986,3 +1146,107 @@ Region::region_list_equivalent (boost::shared_ptr<const Region> other) const
 {
 	return size_equivalent (other) && source_equivalent (other) && _name == other->_name;
 }
+
+void
+Region::source_deleted (boost::shared_ptr<Source>)
+{
+	delete this;
+}
+
+vector<string>
+Region::master_source_names ()
+{
+	SourceList::iterator i;
+
+	vector<string> names;
+	for (i = _master_sources.begin(); i != _master_sources.end(); ++i) {
+		names.push_back((*i)->name());
+	}
+
+	return names;
+}
+
+bool
+Region::source_equivalent (boost::shared_ptr<const Region> other) const
+{
+	if (!other)
+		return false;
+
+	SourceList::const_iterator i;
+	SourceList::const_iterator io;
+
+	for (i = _sources.begin(), io = other->_sources.begin(); i != _sources.end() && io != other->_sources.end(); ++i, ++io) {
+		if ((*i)->id() != (*io)->id()) {
+			return false;
+		}
+	}
+
+	for (i = _master_sources.begin(), io = other->_master_sources.begin(); i != _master_sources.end() && io != other->_master_sources.end(); ++i, ++io) {
+		if ((*i)->id() != (*io)->id()) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool
+Region::verify_length (nframes_t len)
+{
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		if (_start > _sources[n]->length() - len) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool
+Region::verify_start_and_length (nframes_t new_start, nframes_t new_length)
+{
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		if (new_length > _sources[n]->length() - new_start) {
+			return false;
+		}
+	}
+	return true;
+}
+bool
+Region::verify_start (nframes_t pos)
+{
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		if (pos > _sources[n]->length() - _length) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool
+Region::verify_start_mutable (nframes_t& new_start)
+{
+	for (uint32_t n=0; n < _sources.size(); ++n) {
+		if (new_start > _sources[n]->length() - _length) {
+			new_start = _sources[n]->length() - _length;
+		}
+	}
+	return true;
+}
+
+boost::shared_ptr<Region>
+Region::get_parent() const
+{
+	boost::shared_ptr<Playlist> pl (playlist());
+
+	if (pl) {
+		boost::shared_ptr<Region> r;
+		boost::shared_ptr<Region const> grrr2 = boost::dynamic_pointer_cast<Region const> (shared_from_this());
+		
+		if (grrr2 && (r = pl->session().find_whole_file_parent (grrr2))) {
+			return boost::static_pointer_cast<Region> (r);
+		}
+	}
+	
+	return boost::shared_ptr<Region>();
+}
+
diff --git a/libs/ardour/region_factory.cc b/libs/ardour/region_factory.cc
index 631c27b42f..a0aa3be759 100644
--- a/libs/ardour/region_factory.cc
+++ b/libs/ardour/region_factory.cc
@@ -25,6 +25,8 @@
 #include <ardour/region.h>
 #include <ardour/audioregion.h>
 #include <ardour/audiosource.h>
+#include <ardour/midi_source.h>
+#include <ardour/midi_region.h>
 
 #include "i18n.h"
 
@@ -38,16 +40,25 @@ RegionFactory::create (boost::shared_ptr<Region> region, nframes_t start,
 			     nframes_t length, std::string name, 
 			     layer_t layer, Region::Flag flags, bool announce)
 {
-	boost::shared_ptr<const AudioRegion> other;
+	boost::shared_ptr<const AudioRegion> other_a;
+	boost::shared_ptr<const MidiRegion> other_m;
 
-	if ((other = boost::dynamic_pointer_cast<AudioRegion>(region)) != 0) {
-		AudioRegion* ar = new AudioRegion (other, start, length, name, layer, flags);
+	if ((other_a = boost::dynamic_pointer_cast<AudioRegion>(region)) != 0) {
+		AudioRegion* ar = new AudioRegion (other_a, start, length, name, layer, flags);
 		boost::shared_ptr<AudioRegion> arp (ar);
 		boost::shared_ptr<Region> ret (boost::static_pointer_cast<Region> (arp));
 		if (announce) {
 			CheckNewRegion (ret);
 		}
 		return ret;
+	} else if ((other_m = boost::dynamic_pointer_cast<MidiRegion>(region)) != 0) {
+		MidiRegion* ar = new MidiRegion (other_m, start, length, name, layer, flags);
+		boost::shared_ptr<MidiRegion> arp (ar);
+		boost::shared_ptr<Region> ret (boost::static_pointer_cast<Region> (arp));
+		if (announce) {
+			CheckNewRegion (ret);
+		}
+		return ret;
 	} else {
 		fatal << _("programming error: RegionFactory::create() called with unknown Region type")
 		      << endmsg;
@@ -59,10 +70,15 @@ RegionFactory::create (boost::shared_ptr<Region> region, nframes_t start,
 boost::shared_ptr<Region>
 RegionFactory::create (boost::shared_ptr<Region> region)
 {
-	boost::shared_ptr<AudioRegion> other;
+	boost::shared_ptr<AudioRegion> ar;
+	boost::shared_ptr<MidiRegion> mr;
 	
-	if ((other = boost::dynamic_pointer_cast<AudioRegion>(region)) != 0) {
-		boost::shared_ptr<Region> ret (new AudioRegion (other));
+	if ((ar = boost::dynamic_pointer_cast<AudioRegion>(region)) != 0) {
+		boost::shared_ptr<Region> ret (new AudioRegion (ar));
+		/* pure copy constructor - no CheckNewRegion emitted */
+		return ret;
+	} else if ((mr = boost::dynamic_pointer_cast<MidiRegion>(region)) != 0) {
+		boost::shared_ptr<Region> ret (new MidiRegion (mr));
 		/* pure copy constructor - no CheckNewRegion emitted */
 		return ret;
 	} else {
@@ -92,12 +108,33 @@ RegionFactory::create (Session& session, XMLNode& node, bool yn)
 boost::shared_ptr<Region> 
 RegionFactory::create (SourceList& srcs, nframes_t start, nframes_t length, const string& name, layer_t layer, Region::Flag flags, bool announce)
 {
-	boost::shared_ptr<AudioRegion> arp (new AudioRegion (srcs, start, length, name, layer, flags));
-	boost::shared_ptr<Region> ret (boost::static_pointer_cast<Region> (arp));
-	if (announce) {
-		CheckNewRegion (ret);
+	if (srcs.empty()) {
+		return boost::shared_ptr<Region>();
 	}
-	return ret;
+
+	if (srcs[0]->type() == DataType::AUDIO) {
+		
+		AudioRegion* ar = new AudioRegion (srcs, start, length, name, layer, flags);
+		boost::shared_ptr<AudioRegion> arp (ar);
+		boost::shared_ptr<Region> ret (boost::static_pointer_cast<Region> (arp));
+		if (announce) {
+			CheckNewRegion (ret);
+		}
+		return ret;
+
+	} else if (srcs[0]->type() == DataType::MIDI) {
+		
+		MidiRegion* ar = new MidiRegion (srcs, start, length, name, layer, flags);
+		boost::shared_ptr<MidiRegion> mrp (ar);
+		boost::shared_ptr<Region> ret (boost::static_pointer_cast<Region> (mrp));
+		if (announce) {
+			CheckNewRegion (ret);
+		}
+		return ret;
+
+	}
+
+	return boost::shared_ptr<Region> ();
 }	
 
 boost::shared_ptr<Region> 
@@ -107,15 +144,24 @@ RegionFactory::create (SourceList& srcs, const XMLNode& node)
 		return boost::shared_ptr<Region>();
 	}
 
-	boost::shared_ptr<Region> ret (new AudioRegion (srcs, node));
-	CheckNewRegion (ret);
-	return ret;
+	if (srcs[0]->type() == DataType::AUDIO) {
+		boost::shared_ptr<Region> ret (new AudioRegion (srcs, node));
+		CheckNewRegion (ret);
+		return ret;
+	} else if (srcs[0]->type() == DataType::MIDI) {
+		boost::shared_ptr<Region> ret (new MidiRegion (srcs, node));
+		CheckNewRegion (ret);
+		return ret;
+	}
+
+	return boost::shared_ptr<Region> ();
 }
 
 boost::shared_ptr<Region> 
 RegionFactory::create (boost::shared_ptr<Source> src, nframes_t start, nframes_t length, const string& name, layer_t layer, Region::Flag flags, bool announce)
 {
 	boost::shared_ptr<AudioSource> as;
+	boost::shared_ptr<MidiSource> ms;
 
 	if ((as = boost::dynamic_pointer_cast<AudioSource>(src)) != 0) {
 		boost::shared_ptr<Region> ret (new AudioRegion (as, start, length, name, layer, flags));
@@ -123,6 +169,12 @@ RegionFactory::create (boost::shared_ptr<Source> src, nframes_t start, nframes_t
 			CheckNewRegion (ret);
 		}
 		return ret;
+	} else if ((ms = boost::dynamic_pointer_cast<MidiSource>(src)) != 0) {
+		boost::shared_ptr<Region> ret (new MidiRegion (ms, start, length, name, layer, flags));
+		if (announce) {
+			CheckNewRegion (ret);
+		}
+		return ret;
 	}
 
 	return boost::shared_ptr<Region>();
diff --git a/libs/ardour/reverse.cc b/libs/ardour/reverse.cc
index fc58e161aa..c7ebecea31 100644
--- a/libs/ardour/reverse.cc
+++ b/libs/ardour/reverse.cc
@@ -79,7 +79,7 @@ Reverse::run (boost::shared_ptr<AudioRegion> region)
 
 			/* read it in */
 			
-			if (region->source (n)->read (buf, fpos, to_read) != to_read) {
+			if (region->audio_source (n)->read (buf, fpos, to_read) != to_read) {
 				goto out;
 			}
 
@@ -91,7 +91,9 @@ Reverse::run (boost::shared_ptr<AudioRegion> region)
 			
 			/* write it out */
 
-			if ((*si)->write (buf, to_read) != to_read) {
+			boost::shared_ptr<AudioSource> asrc(boost::dynamic_pointer_cast<AudioSource>(*si));
+
+			if (asrc && asrc->write (buf, to_read) != to_read) {
 				goto out;
 			}
 		}
@@ -115,7 +117,8 @@ Reverse::run (boost::shared_ptr<AudioRegion> region)
 
 	if (ret) {
 		for (si = nsrcs.begin(); si != nsrcs.end(); ++si) {
-			(*si)->mark_for_remove ();
+			boost::shared_ptr<AudioSource> asrc(boost::dynamic_pointer_cast<AudioSource>(*si));
+			asrc->mark_for_remove ();
 		}
 	}
 	
diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index 091ff549ad..d361386324 100644
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -26,9 +26,9 @@
 #include <pbd/enumwriter.h>
 
 #include <ardour/timestamps.h>
-#include <ardour/buffer.h>
 #include <ardour/audioengine.h>
 #include <ardour/route.h>
+#include <ardour/buffer.h>
 #include <ardour/insert.h>
 #include <ardour/send.h>
 #include <ardour/session.h>
@@ -37,18 +37,19 @@
 #include <ardour/cycle_timer.h>
 #include <ardour/route_group.h>
 #include <ardour/port.h>
+#include <ardour/audio_port.h>
 #include <ardour/ladspa_plugin.h>
 #include <ardour/panner.h>
 #include <ardour/dB.h>
-#include <ardour/mix.h>
-
+#include <ardour/amp.h>
+#include <ardour/meter.h>
+#include <ardour/buffer_set.h>
 #include "i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
 using namespace PBD;
 
-
 uint32_t Route::order_key_cnt = 0;
 
 
@@ -73,7 +74,7 @@ Route::Route (Session& sess, const XMLNode& node, DataType default_type)
 void
 Route::init ()
 {
-	redirect_max_outs = 0;
+	redirect_max_outs.reset();
 	_muted = false;
 	_soloed = false;
 	_solo_safe = false;
@@ -89,7 +90,6 @@ Route::init ()
 	_declickable = false;
 	_pending_declick = true;
 	_remote_control_id = 0;
-	_ignore_gain_on_deliver = true;
 	
 	_edit_group = 0;
 	_mix_group = 0;
@@ -221,18 +221,30 @@ Route::set_gain (gain_t val, void *src)
 	IO::set_gain (val, src);
 }
 
+/** Process this route for one (sub) cycle (process thread)
+ *
+ * @param bufs Scratch buffers to use for the signal path
+ * @param start_frame Initial transport frame 
+ * @param end_frame Final transport frame
+ * @param nframes Number of frames to output (to ports)
+ * @param offset Output offset (of port buffers, for split cycles)
+ *
+ * Note that (end_frame - start_frame) may not be equal to nframes when the
+ * transport speed isn't 1.0 (eg varispeed).
+ */
 void
-Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
-			       nframes_t start_frame, nframes_t end_frame, 
-			       nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
-			       bool meter)
+Route::process_output_buffers (BufferSet& bufs,
+		nframes_t start_frame, nframes_t end_frame, 
+        nframes_t nframes, nframes_t offset, bool with_redirects, int declick,
+		bool meter)
 {
-	uint32_t n;
+	// This is definitely very audio-only for now
+	assert(_default_type == DataType::AUDIO);
+	
 	RedirectList::iterator i;
 	bool post_fader_work = false;
 	bool mute_declick_applied = false;
 	gain_t dmg, dsg, dg;
-	vector<Sample*>::iterator bufiter;
 	IO *co;
 	bool mute_audible;
 	bool solo_audible;
@@ -279,17 +291,17 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	   -------------------------------------------------------------------------------------------------- */
 
 	if (declick > 0) {
-		apply_declick (bufs, nbufs, nframes, 0.0, 1.0, false);
+		Amp::run (bufs, nframes, 0.0, 1.0, false);
 		_pending_declick = 0;
 	} else if (declick < 0) {
-		apply_declick (bufs, nbufs, nframes, 1.0, 0.0, false);
+		Amp::run (bufs, nframes, 1.0, 0.0, false);
 		_pending_declick = 0;
 	} else {
 
 		/* no global declick */
 
 		if (solo_gain != dsg) {
-			apply_declick (bufs, nbufs, nframes, solo_gain, dsg, false);
+			Amp::run (bufs, nframes, solo_gain, dsg, false);
 			solo_gain = dsg;
 		}
 	}
@@ -300,13 +312,11 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	   -------------------------------------------------------------------------------------------------- */
 
 	if (meter && (_meter_point == MeterInput)) {
-		for (n = 0; n < nbufs; ++n) {
-			_peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]); 
-		}
+		_meter->run(bufs, nframes);
 	}
 
 	if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
-		apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+		Amp::run (bufs, nframes, mute_gain, dmg, false);
 		mute_gain = dmg;
 		mute_declick_applied = true;
 	}
@@ -336,15 +346,19 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 			
 		} else {
 
-			co->deliver_output (bufs, nbufs, nframes, offset);
+			co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 			
 		} 
 	} 
 
-	/* ----------------------------------------------------------------------------------------------------
+	/* ---------------------------------------------------------------------------------------------------
 	   PRE-FADER REDIRECTS
 	   -------------------------------------------------------------------------------------------------- */
 
+	/* FIXME: Somewhere in these loops is where bufs.count() should go from n_inputs() to redirect_max_outs()
+	 * (if they differ).  Something explicit needs to be done here to make sure the list of redirects will
+	 * give us what we need (possibly by inserting transparent 'translators' into the list to make it work) */
+
 	if (with_redirects) {
 		Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
 		if (rm.locked()) {
@@ -352,13 +366,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 				for (i = _redirects.begin(); i != _redirects.end(); ++i) {
 					switch ((*i)->placement()) {
 					case PreFader:
-						if (dsg == 0) {
-							if (boost::dynamic_pointer_cast<Send>(*i) || boost::dynamic_pointer_cast<PortInsert>(*i)) {
-								(*i)->silence (nframes, offset);
-							}
-						} else {
-							(*i)->run (bufs, nbufs, nframes, offset);
-						}
+						(*i)->run (bufs, start_frame, end_frame, nframes, offset);
 						break;
 					case PostFader:
 						post_fader_work = true;
@@ -380,9 +388,12 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 		} 
 	}
 
+	// FIXME: for now, just hope the redirects list did what it was supposed to
+	bufs.set_count(n_process_buffers());
 
+	
 	if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_post_fader) {
-		apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+		Amp::run (bufs, nframes, mute_gain, dmg, false);
 		mute_gain = dmg;
 		mute_declick_applied = true;
 	}
@@ -392,9 +403,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	   -------------------------------------------------------------------------------------------------- */
 
 	if (meter && (_meter_point == MeterPreFader)) {
-		for (n = 0; n < nbufs; ++n) {
-			_peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
-		}
+		_meter->run(bufs, nframes);
 	}
 
 	
@@ -421,8 +430,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 			
 		} else {
 
-			co->deliver_output (bufs, nbufs, nframes, offset);
-			
+			co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 		} 
 	} 
 	
@@ -449,16 +457,16 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 		if (apply_gain_automation) {
 			
 			if (_phase_invert) {
-				for (n = 0; n < nbufs; ++n)  {
-					Sample *sp = bufs[n];
+				for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+					Sample* const sp = i->data();
 					
 					for (nframes_t nx = 0; nx < nframes; ++nx) {
 						sp[nx] *= -gab[nx];
 					}
 				}
 			} else {
-				for (n = 0; n < nbufs; ++n) {
-					Sample *sp = bufs[n];
+				for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+					Sample* const sp = i->data();
 					
 					for (nframes_t nx = 0; nx < nframes; ++nx) {
 						sp[nx] *= gab[nx];
@@ -476,7 +484,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 			
 			if (_gain != dg) {
 				
-				apply_declick (bufs, nbufs, nframes, _gain, dg, _phase_invert);
+				Amp::run (bufs, nframes, _gain, dg, _phase_invert);
 				_gain = dg;
 				
 			} else if (_gain != 0 && (_phase_invert || _gain != 1.0)) {
@@ -495,14 +503,14 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 					this_gain = _gain;
 				}
 				
-				for (n = 0; n < nbufs; ++n) {
-					Sample *sp = bufs[n];
-					Session::apply_gain_to_buffer(sp,nframes,this_gain);
+				for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+					Sample* const sp = i->data();
+					apply_gain_to_buffer(sp,nframes,this_gain);
 				}
 
 			} else if (_gain == 0) {
-				for (n = 0; n < nbufs; ++n) {
-					memset (bufs[n], 0, sizeof (Sample) * nframes);
+				for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
+					i->clear();
 				}
 			}
 		}
@@ -529,13 +537,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 					case PreFader:
 						break;
 					case PostFader:
-						if (dsg == 0) {
-							if (boost::dynamic_pointer_cast<Send>(*i) || boost::dynamic_pointer_cast<PortInsert>(*i)) {
-								(*i)->silence (nframes, offset);
-							}
-						} else {
-							(*i)->run (bufs, nbufs, nframes, offset);
-						}
+						(*i)->run (bufs, start_frame, end_frame, nframes, offset);
 						break;
 					}
 				}
@@ -554,7 +556,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	}
 
 	if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_control_outs) {
-		apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+		Amp::run (bufs, nframes, mute_gain, dmg, false);
 		mute_gain = dmg;
 		mute_declick_applied = true;
 	}
@@ -585,12 +587,12 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 			(no_monitor && record_enabled() && (!Config->get_auto_input() || _session.actively_recording()))
 
 			) {
-
+			
 			co->silence (nframes, offset);
 			
 		} else {
 
-			co->deliver_output_no_pan (bufs, nbufs, nframes, offset);
+			co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
 		} 
 	} 
 
@@ -599,7 +601,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	   ----------------------------------------------------------------------*/
 
 	if (!_soloed && (mute_gain != dmg) && !mute_declick_applied && _mute_affects_main_outs) {
-		apply_declick (bufs, nbufs, nframes, mute_gain, dmg, false);
+		Amp::run (bufs, nframes, mute_gain, dmg, false);
 		mute_gain = dmg;
 		mute_declick_applied = true;
 	}
@@ -611,7 +613,7 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	solo_audible = dsg > 0;
 	mute_audible = dmg > 0 || !_mute_affects_main_outs;
 	
-	if (n_outputs() == 0) {
+	if (n_outputs().get(_default_type) == 0) {
 	    
 	    /* relax */
 
@@ -640,27 +642,15 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 			*/
 			
 			if (_meter_point == MeterPostFader) {
-				reset_peak_meters ();
+				peak_meter().reset();
 			}
-			
+
 			IO::silence (nframes, offset);
 			
 		} else {
 			
-			if ((_session.transport_speed() > 1.5f || 
-			     _session.transport_speed() < -1.5f) &&
-			    Config->get_quieten_at_speed()) {
-				pan (bufs, nbufs, nframes, offset, speed_quietning); 
-			} else {
-				// cerr << _name << " panner state = " << _panner->automation_state() << endl;
-				if (!_panner->empty() &&
-				    (_panner->automation_state() & Play ||
-				     ((_panner->automation_state() & Touch) && !_panner->touching()))) {
-					pan_automated (bufs, nbufs, start_frame, end_frame, nframes, offset);
-				} else {
-					pan (bufs, nbufs, nframes, offset, 1.0); 
-				}
-			}
+			deliver_output(bufs, start_frame, end_frame, nframes, offset);
+
 		}
 
 	}
@@ -670,62 +660,47 @@ Route::process_output_buffers (vector<Sample*>& bufs, uint32_t nbufs,
 	   -------------------------------------------------------------------------------------------------- */
 
 	if (meter && (_meter_point == MeterPostFader)) {
-//		cerr << "meter post" << endl;
-
 		if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
-			uint32_t no = n_outputs();
-			for (n = 0; n < no; ++n) {
-				_peak_power[n] = 0;
-			} 
+			_meter->reset();
 		} else {
-			uint32_t no = n_outputs();
-			for (n = 0; n < no; ++n) {
-				_peak_power[n] = Session::compute_peak (output(n)->get_buffer (nframes) + offset, nframes, _peak_power[n]);
-			}
+			_meter->run(output_buffers(), nframes, offset);
 		}
 	}
 }
 
-uint32_t
+ChanCount
 Route::n_process_buffers ()
 {
 	return max (n_inputs(), redirect_max_outs);
 }
 
 void
-
 Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
 {
-	vector<Sample*>& bufs = _session.get_passthru_buffers();
-	uint32_t limit = n_process_buffers ();
+	BufferSet& bufs = _session.get_scratch_buffers(n_process_buffers());
 
 	_silent = false;
 
-	collect_input (bufs, limit, nframes, offset);
+	collect_input (bufs, nframes, offset);
 
 #define meter_stream meter_first
 
 	if (meter_first) {
-		for (uint32_t n = 0; n < limit; ++n) {
-			_peak_power[n] = Session::compute_peak (bufs[n], nframes, _peak_power[n]);
-		}
+		_meter->run(bufs, nframes);
 		meter_stream = false;
 	} else {
 		meter_stream = true;
 	}
 		
-	process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
+	process_output_buffers (bufs, start_frame, end_frame, nframes, offset, true, declick, meter_stream);
 
 #undef meter_stream
 }
 
 void
-Route::set_phase_invert (bool yn, void *src)
+Route::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
 {
-	if (_phase_invert != yn) {
-		_phase_invert = yn;
-	}
-	//  phase_invert_changed (src); /* EMIT SIGNAL */
+	process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, offset, true, declick, meter);
 }
 
 void
@@ -790,7 +765,7 @@ Route::set_mute (bool yn, void *src)
 int
 Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
 {
-	uint32_t old_rmo = redirect_max_outs;
+	ChanCount old_rmo = redirect_max_outs;
 
 	if (!_session.engine().connected()) {
 		return 1;
@@ -802,17 +777,15 @@ Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t*
 		boost::shared_ptr<PluginInsert> pi;
 		boost::shared_ptr<PortInsert> porti;
 
-		uint32_t potential_max_streams = 0;
+		redirect->set_default_type(_default_type);
 
 		if ((pi = boost::dynamic_pointer_cast<PluginInsert>(redirect)) != 0) {
 			pi->set_count (1);
 
-			if (pi->input_streams() == 0) {
-				/* instrument plugin */
+			if (pi->input_streams() == ChanCount::ZERO) {
+				/* generator plugin */
 				_have_internal_generator = true;
 			}
-
-			potential_max_streams = max(pi->input_streams(), pi->output_streams());
 			
 		} else if ((porti = boost::dynamic_pointer_cast<PortInsert>(redirect)) != 0) {
 
@@ -825,22 +798,15 @@ Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t*
 			   the "outputs" of the route should match the inputs of this
 			   route. XXX shouldn't they match the number of active signal
 			   streams at the point of insertion?
-			   
 			*/
+			// FIXME: (yes, they should)
 
 			porti->ensure_io (n_outputs (), n_inputs(), false, this);
 		}
-
+		
 		// Ensure peak vector sizes before the plugin is activated
-		while (_peak_power.size() < potential_max_streams) {
-			_peak_power.push_back(0);
-		}
-		while (_visible_peak_power.size() < potential_max_streams) {
-			_visible_peak_power.push_back(-INFINITY);
-		}
-		while (_max_peak_power.size() < potential_max_streams) {
-			_max_peak_power.push_back(-INFINITY);
-		}
+		ChanCount potential_max_streams = max(redirect->input_streams(), redirect->output_streams());
+		_meter->setup(potential_max_streams);
 
 		_redirects.push_back (redirect);
 
@@ -854,7 +820,7 @@ Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t*
 		redirect->active_changed.connect (mem_fun (*this, &Route::redirect_active_proxy));
 	}
 	
-	if (redirect_max_outs != old_rmo || old_rmo == 0) {
+	if (redirect_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
 		reset_panner ();
 	}
 
@@ -866,7 +832,7 @@ Route::add_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t*
 int
 Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_streams)
 {
-	uint32_t old_rmo = redirect_max_outs;
+	ChanCount old_rmo = redirect_max_outs;
 
 	if (!_session.engine().connected()) {
 		return 1;
@@ -878,7 +844,7 @@ Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_strea
 		RedirectList::iterator existing_end = _redirects.end();
 		--existing_end;
 
-		uint32_t potential_max_streams = 0;
+		ChanCount potential_max_streams;
 
 		for (RedirectList::const_iterator i = others.begin(); i != others.end(); ++i) {
 			
@@ -887,21 +853,13 @@ Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_strea
 			if ((pi = boost::dynamic_pointer_cast<PluginInsert>(*i)) != 0) {
 				pi->set_count (1);
 				
-				uint32_t m = max(pi->input_streams(), pi->output_streams());
+				ChanCount m = max(pi->input_streams(), pi->output_streams());
 				if (m > potential_max_streams)
 					potential_max_streams = m;
 			}
 
 			// Ensure peak vector sizes before the plugin is activated
-			while (_peak_power.size() < potential_max_streams) {
-				_peak_power.push_back(0);
-			}
-			while (_visible_peak_power.size() < potential_max_streams) {
-				_visible_peak_power.push_back(-INFINITY);
-			}
-			while (_max_peak_power.size() < potential_max_streams) {
-				_max_peak_power.push_back(-INFINITY);
-			}
+			_meter->setup(potential_max_streams);
 
 			_redirects.push_back (*i);
 			
@@ -917,7 +875,7 @@ Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_strea
 		}
 	}
 	
-	if (redirect_max_outs != old_rmo || old_rmo == 0) {
+	if (redirect_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
 		reset_panner ();
 	}
 
@@ -931,7 +889,7 @@ Route::add_redirects (const RedirectList& others, void *src, uint32_t* err_strea
 void
 Route::clear_redirects (Placement p, void *src)
 {
-	const uint32_t old_rmo = redirect_max_outs;
+	const ChanCount old_rmo = redirect_max_outs;
 
 	if (!_session.engine().connected()) {
 		return;
@@ -959,7 +917,7 @@ Route::clear_redirects (Placement p, void *src)
 		reset_panner ();
 	}
 	
-	redirect_max_outs = 0;
+	redirect_max_outs.reset();
 	_have_internal_generator = false;
 	redirects_changed (src); /* EMIT SIGNAL */
 }
@@ -967,13 +925,13 @@ Route::clear_redirects (Placement p, void *src)
 int
 Route::remove_redirect (boost::shared_ptr<Redirect> redirect, void *src, uint32_t* err_streams)
 {
-	uint32_t old_rmo = redirect_max_outs;
+	ChanCount old_rmo = redirect_max_outs;
 
 	if (!_session.engine().connected()) {
 		return 1;
 	}
 
-	redirect_max_outs = 0;
+	redirect_max_outs.reset();
 
 	{
 		Glib::RWLock::WriterLock lm (redirect_lock);
@@ -1071,7 +1029,7 @@ Route::_reset_plugin_counts (uint32_t* err_streams)
 	map<Placement,list<InsertCount> > insert_map;
 	nframes_t initial_streams;
 
-	redirect_max_outs = 0;
+	redirect_max_outs.reset();
 	i_cnt = 0;
 	s_cnt = 0;
 
@@ -1125,7 +1083,7 @@ Route::_reset_plugin_counts (uint32_t* err_streams)
 
 	/* A: PreFader */
 	
-	if (check_some_plugin_counts (insert_map[PreFader], n_inputs (), err_streams)) {
+	if (check_some_plugin_counts (insert_map[PreFader], n_inputs ().get(_default_type), err_streams)) {
 		return -1;
 	}
 
@@ -1135,7 +1093,7 @@ Route::_reset_plugin_counts (uint32_t* err_streams)
 		InsertCount& ic (insert_map[PreFader].back());
 		initial_streams = ic.insert->compute_output_streams (ic.cnt);
 	} else {
-		initial_streams = n_inputs ();
+		initial_streams = n_inputs ().get(_default_type);
 	}
 
 	/* B: PostFader */
@@ -1153,7 +1111,7 @@ Route::_reset_plugin_counts (uint32_t* err_streams)
 
   recompute:
 
-	redirect_max_outs = 0;
+	redirect_max_outs.reset();
 	RedirectList::iterator prev = _redirects.end();
 
 	for (r = _redirects.begin(); r != _redirects.end(); prev = r, ++r) {
@@ -1225,7 +1183,7 @@ Route::check_some_plugin_counts (list<InsertCount>& iclist, int32_t required_inp
 int
 Route::copy_redirects (const Route& other, Placement placement, uint32_t* err_streams)
 {
-	uint32_t old_rmo = redirect_max_outs;
+	ChanCount old_rmo = redirect_max_outs;
 
 	if (err_streams) {
 		*err_streams = 0;
@@ -1298,7 +1256,7 @@ Route::copy_redirects (const Route& other, Placement placement, uint32_t* err_st
 		}
 	}
 
-	if (redirect_max_outs != old_rmo || old_rmo == 0) {
+	if (redirect_max_outs != old_rmo || old_rmo == ChanCount::ZERO) {
 		reset_panner ();
 	}
 
@@ -1354,7 +1312,7 @@ Route::sort_redirects (uint32_t* err_streams)
 	{
 		RedirectSorter comparator;
 		Glib::RWLock::WriterLock lm (redirect_lock);
-		uint32_t old_rmo = redirect_max_outs;
+		ChanCount old_rmo = redirect_max_outs;
 
 		/* the sweet power of C++ ... */
 
@@ -1770,8 +1728,6 @@ Route::silence (nframes_t nframes, nframes_t offset)
 {
 	if (!_silent) {
 
-		// reset_peak_meters ();
-		
 		IO::silence (nframes, offset);
 
 		if (_control_outs) {
@@ -1806,11 +1762,17 @@ Route::set_control_outs (const vector<string>& ports)
 {
 	Glib::Mutex::Lock lm (control_outs_lock);
 	vector<string>::const_iterator i;
-
+	size_t limit;
+	
  	if (_control_outs) {
  		delete _control_outs;
  		_control_outs = 0;
  	}
+
+	if (control() || master()) {
+		/* no control outs for these two special busses */
+		return 0;
+	}
  	
  	if (ports.empty()) {
  		return 0;
@@ -1822,10 +1784,25 @@ Route::set_control_outs (const vector<string>& ports)
  	_control_outs = new IO (_session, coutname);
 
 	/* our control outs need as many outputs as we
-	   have outputs. we track the changes in ::output_change_handler().
+	   have audio outputs. we track the changes in ::output_change_handler().
 	*/
+	
+	// XXX its stupid that we have to get this value twice
 
-	_control_outs->ensure_io (0, n_outputs(), true, this);
+	limit = n_outputs().get(DataType::AUDIO);
+	
+	if (_control_outs->ensure_io (ChanCount::ZERO, ChanCount (DataType::AUDIO, n_outputs().get (DataType::AUDIO)), true, this)) {
+		return -1;
+	}
+	
+	/* now connect to the named ports */
+	
+	for (size_t n = 0; n < limit; ++n) {
+		if (_control_outs->connect_output (_control_outs->output (n), ports[n], this)) {
+			error << string_compose (_("could not connect %1 to %2"), _control_outs->output(n)->name(), ports[n]) << endmsg;
+			return -1;
+		}
+	}
  
  	return 0;
 }	
@@ -1900,8 +1877,8 @@ Route::feeds (boost::shared_ptr<Route> other)
 	uint32_t i, j;
 
 	IO& self = *this;
-	uint32_t no = self.n_outputs();
-	uint32_t ni = other->n_inputs ();
+	uint32_t no = self.n_outputs().get_total();
+	uint32_t ni = other->n_inputs ().get_total();
 
 	for (i = 0; i < no; ++i) {
 		for (j = 0; j < ni; ++j) {
@@ -1915,7 +1892,7 @@ Route::feeds (boost::shared_ptr<Route> other)
 
 	for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); r++) {
 
-		no = (*r)->n_outputs();
+		no = (*r)->n_outputs().get_total();
 
 		for (i = 0; i < no; ++i) {
 			for (j = 0; j < ni; ++j) {
@@ -1930,7 +1907,7 @@ Route::feeds (boost::shared_ptr<Route> other)
 
 	if (_control_outs) {
 
-		no = _control_outs->n_outputs();
+		no = _control_outs->n_outputs().get_total();
 		
 		for (i = 0; i < no; ++i) {
 			for (j = 0; j < ni; ++j) {
@@ -2041,7 +2018,7 @@ Route::output_change_handler (IOChange change, void *ignored)
 {
 	if (change & ConfigurationChanged) {
 		if (_control_outs) {
-			_control_outs->ensure_io (0, n_outputs(), true, this);
+			_control_outs->ensure_io (ChanCount::ZERO, ChanCount(DataType::AUDIO, n_outputs().get(DataType::AUDIO)), true, this);
 		}
 		
 		reset_plugin_counts (0);
@@ -2051,18 +2028,18 @@ Route::output_change_handler (IOChange change, void *ignored)
 uint32_t
 Route::pans_required () const
 {
-	if (n_outputs() < 2) {
+	if (n_outputs().get(DataType::AUDIO) < 2) {
 		return 0;
 	}
 	
-	return max (n_inputs (), redirect_max_outs);
+	return max (n_inputs ().get(DataType::AUDIO), static_cast<size_t>(redirect_max_outs.get(DataType::AUDIO)));
 }
 
 int 
 Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, 
 		   bool session_state_changing, bool can_record, bool rec_monitors_input)
 {
-	if (n_outputs() == 0) {
+	if (n_outputs().get_total() == 0) {
 		return 0;
 	}
 
@@ -2073,7 +2050,7 @@ Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, n
 
 	apply_gain_automation = false;
 	
-	if (n_inputs()) {
+	if (n_inputs().get_total()) {
 		passthru (start_frame, end_frame, nframes, offset, 0, false);
 	} else {
 		silence (nframes, offset);
@@ -2120,7 +2097,7 @@ Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nfra
 		}
 	}
 
-	if ((n_outputs() == 0 && _redirects.empty()) || n_inputs() == 0 || !_active) {
+	if ((n_outputs().get_total() == 0 && _redirects.empty()) || n_inputs().get_total() == 0 || !_active) {
 		silence (nframes, offset);
 		return 0;
 	}
@@ -2140,8 +2117,6 @@ Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nfra
 		
 		if (am.locked() && _session.transport_rolling()) {
 			
-			nframes_t start_frame = end_frame - nframes;
-			
 			if (gain_automation_playback()) {
 				apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
 			}
@@ -2164,8 +2139,8 @@ Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_fram
 void
 Route::toggle_monitor_input ()
 {
-	for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
-		(*i)->ensure_monitor_input(!(*i)->monitoring_input());
+	for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+		i->ensure_monitor_input( ! i->monitoring_input());
 	}
 }
 
@@ -2177,11 +2152,10 @@ Route::has_external_redirects () const
 	for (RedirectList::const_iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
 		if ((pi = boost::dynamic_pointer_cast<const PortInsert>(*i)) != 0) {
 
-			uint32_t no = pi->n_outputs();
-
-			for (uint32_t n = 0; n < no; ++n) {
+			for (PortSet::const_iterator port = pi->outputs().begin();
+					port != pi->outputs().end(); ++port) {
 				
-				string port_name = pi->output(n)->name();
+				string port_name = port->name();
 				string client_name = port_name.substr (0, port_name.find(':'));
 
 				/* only say "yes" if the redirect is actually in use */
diff --git a/libs/ardour/send.cc b/libs/ardour/send.cc
index faafa3295e..39c917571a 100644
--- a/libs/ardour/send.cc
+++ b/libs/ardour/send.cc
@@ -24,7 +24,9 @@
 #include <ardour/send.h>
 #include <ardour/session.h>
 #include <ardour/port.h>
-
+#include <ardour/audio_port.h>
+#include <ardour/buffer_set.h>
+#include <ardour/meter.h>
 #include "i18n.h"
 
 using namespace ARDOUR;
@@ -34,7 +36,6 @@ Send::Send (Session& s, Placement p)
 	: Redirect (s, string_compose (_("send %1"), (bitslot = s.next_send_id()) + 1), p)
 {
 	_metering = false;
-	expected_inputs = 0;
 	RedirectCreated (this); /* EMIT SIGNAL */
 }
 
@@ -42,7 +43,6 @@ Send::Send (Session& s, const XMLNode& node)
 	: Redirect (s,  "send", PreFader)
 {
 	_metering = false;
-	expected_inputs = 0;
 
 	if (set_state (node)) {
 		throw failed_constructor();
@@ -55,8 +55,6 @@ Send::Send (const Send& other)
 	: Redirect (other._session, string_compose (_("send %1"), (bitslot = other._session.next_send_id()) + 1), other.placement())
 {
 	_metering = false;
-	expected_inputs = 0;
-
 	RedirectCreated (this); /* EMIT SIGNAL */
 }
 
@@ -116,37 +114,25 @@ Send::set_state(const XMLNode& node)
 }
 
 void
-Send::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t offset)
+Send::run (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
 {
 	if (active()) {
 
 		// we have to copy the input, because IO::deliver_output may alter the buffers
 		// in-place, which a send must never do.
 
-		vector<Sample*>& sendbufs = _session.get_send_buffers();
+		BufferSet& sendbufs = _session.get_send_buffers(bufs.count());
 
-		for (size_t i=0; i < nbufs; ++i) {
-			memcpy (sendbufs[i], bufs[i], sizeof (Sample) * nframes);
-		}
-		
-		
-		IO::deliver_output (sendbufs, nbufs, nframes, offset);
+		sendbufs.read_from(bufs, nframes);
+		assert(sendbufs.count() == bufs.count());
 
-		if (_metering) {
-			uint32_t n;
-			uint32_t no = n_outputs();
+		IO::deliver_output (sendbufs, start_frame, end_frame, nframes, offset);
 
+		if (_metering) {
 			if (_gain == 0) {
-
-				for (n = 0; n < no; ++n) {
-					_peak_power[n] = 0;
-				} 
-
+				_meter->reset();
 			} else {
-
-				for (n = 0; n < no; ++n) {
-					_peak_power[n] = Session::compute_peak (output(n)->get_buffer(nframes) + offset, nframes, _peak_power[n]);
-				}
+				_meter->run(output_buffers(), nframes, offset);
 			}
 		}
 
@@ -154,12 +140,7 @@ Send::run (vector<Sample *>& bufs, uint32_t nbufs, nframes_t nframes, nframes_t
 		silence (nframes, offset);
 		
 		if (_metering) {
-			uint32_t n;
-			uint32_t no = n_outputs();
-
-			for (n = 0; n < no; ++n) {
-				_peak_power[n] = 0;
-			} 
+			_meter->reset();
 		}
 	}
 }
@@ -171,15 +152,15 @@ Send::set_metering (bool yn)
 
 	if (!_metering) {
 		/* XXX possible thread hazard here */
-		reset_peak_meters ();
+		peak_meter().reset();
 	}
 }
 
 void
-Send::expect_inputs (uint32_t expected)
+Send::expect_inputs (const ChanCount& expected)
 {
-	if (expected != expected_inputs) {
-		expected_inputs = expected;
+	if (expected != _expected_inputs) {
+		_expected_inputs = expected;
 		reset_panner ();
 	}
 }
diff --git a/libs/ardour/session.cc b/libs/ardour/session.cc
index 0644a5c84b..d29795904e 100644
--- a/libs/ardour/session.cc
+++ b/libs/ardour/session.cc
@@ -44,11 +44,15 @@
 #include <ardour/audioengine.h>
 #include <ardour/configuration.h>
 #include <ardour/session.h>
-#include <ardour/audio_diskstream.h>
 #include <ardour/utils.h>
+#include <ardour/audio_diskstream.h>
 #include <ardour/audioplaylist.h>
 #include <ardour/audioregion.h>
 #include <ardour/audiofilesource.h>
+#include <ardour/midi_diskstream.h>
+#include <ardour/midi_playlist.h>
+#include <ardour/midi_region.h>
+#include <ardour/smf_source.h>
 #include <ardour/auditioner.h>
 #include <ardour/recent_sessions.h>
 #include <ardour/redirect.h>
@@ -58,12 +62,14 @@
 #include <ardour/slave.h>
 #include <ardour/tempo.h>
 #include <ardour/audio_track.h>
+#include <ardour/midi_track.h>
 #include <ardour/cycle_timer.h>
 #include <ardour/named_selection.h>
 #include <ardour/crossfade.h>
 #include <ardour/playlist.h>
 #include <ardour/click.h>
 #include <ardour/data_type.h>
+#include <ardour/buffer_set.h>
 #include <ardour/source_factory.h>
 #include <ardour/region_factory.h>
 
@@ -94,12 +100,6 @@ const char* Session::dead_sound_dir_name = X_("dead_sounds");
 const char* Session::interchange_dir_name = X_("interchange");
 const char* Session::export_dir_name = X_("export");
 
-Session::compute_peak_t			Session::compute_peak 		= 0;
-Session::find_peaks_t			Session::find_peaks 		= 0;
-Session::apply_gain_to_buffer_t		Session::apply_gain_to_buffer 	= 0;
-Session::mix_buffers_with_gain_t	Session::mix_buffers_with_gain 	= 0;
-Session::mix_buffers_no_gain_t		Session::mix_buffers_no_gain 	= 0;
-
 sigc::signal<int> Session::AskAboutPendingState;
 sigc::signal<void> Session::SendFeedback;
 
@@ -263,11 +263,15 @@ Session::Session (AudioEngine &eng,
 		  string* mix_template)
 
 	: _engine (eng),
+	  _scratch_buffers(new BufferSet()),
+	  _silent_buffers(new BufferSet()),
+	  _send_buffers(new BufferSet()),
 	  _mmc_port (default_mmc_port),
 	  _mtc_port (default_mtc_port),
 	  _midi_port (default_midi_port),
 	  pending_events (2048),
-	  midi_requests (128), // the size of this should match the midi request pool size
+	  //midi_requests (128), // the size of this should match the midi request pool size
+	  _send_smpte_update (false),
 	  diskstreams (new DiskstreamList),
 	  routes (new RouteList),
 	  auditioner ((Auditioner*) 0),
@@ -326,11 +330,15 @@ Session::Session (AudioEngine &eng,
 		  nframes_t initial_length)
 
 	: _engine (eng),
+	  _scratch_buffers(new BufferSet()),
+	  _silent_buffers(new BufferSet()),
+	  _send_buffers(new BufferSet()),
 	  _mmc_port (default_mmc_port),
 	  _mtc_port (default_mtc_port),
 	  _midi_port (default_midi_port),
 	  pending_events (2048),
-	  midi_requests (16),
+	  //midi_requests (16),
+	  _send_smpte_update (false),
 	  diskstreams (new DiskstreamList),
 	  routes (new RouteList),
 	  main_outs (0)
@@ -450,7 +458,7 @@ Session::destroy ()
 	}
 
 	terminate_butler_thread ();
-	terminate_midi_thread ();
+	//terminate_midi_thread ();
 	
 	if (click_data && click_data != default_click) {
 		delete [] click_data;
@@ -462,23 +470,11 @@ Session::destroy ()
 
 	clear_clicks ();
 
-	for (vector<Sample*>::iterator i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i) {
-		free(*i);
-	}
-
-	for (vector<Sample*>::iterator i = _silent_buffers.begin(); i != _silent_buffers.end(); ++i) {
-		free(*i);
-	}
-
- 	for (vector<Sample*>::iterator i = _send_buffers.begin(); i != _send_buffers.end(); ++i) {
- 		free(*i);
- 	}
+	delete _scratch_buffers;
+	delete _silent_buffers;
+	delete _send_buffers;
 
 	AudioDiskstream::free_working_buffers();
-
-	/* this should cause deletion of the auditioner */
-
-	// auditioner.reset ();
 	
 #undef TRACK_DESTRUCTION
 #ifdef TRACK_DESTRUCTION
@@ -523,11 +519,11 @@ Session::destroy ()
 	unused_playlists.clear ();
 
 #ifdef TRACK_DESTRUCTION
-	cerr << "delete audio regions\n";
+	cerr << "delete regions\n";
 #endif /* TRACK_DESTRUCTION */
 	
-	for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); ) {
-		AudioRegionList::iterator tmp;
+	for (RegionList::iterator i = regions.begin(); i != regions.end(); ) {
+		RegionList::iterator tmp;
 
 		tmp = i;
 		++tmp;
@@ -537,8 +533,8 @@ Session::destroy ()
 		i = tmp;
 	}
 
-	audio_regions.clear ();
-	
+	regions.clear ();
+
 #ifdef TRACK_DESTRUCTION
 	cerr << "delete routes\n";
 #endif /* TRACK_DESTRUCTION */
@@ -570,8 +566,8 @@ Session::destroy ()
 #ifdef TRACK_DESTRUCTION
 	cerr << "delete audio sources\n";
 #endif /* TRACK_DESTRUCTION */
-	for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ) {
-		AudioSourceList::iterator tmp;
+	for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
+		SourceMap::iterator tmp;
 
 		tmp = i;
 		++tmp;
@@ -581,7 +577,7 @@ Session::destroy ()
 		i = tmp;
 	}
 
-	audio_sources.clear ();
+	sources.clear ();
 
 #ifdef TRACK_DESTRUCTION
 	cerr << "delete mix groups\n";
@@ -707,8 +703,8 @@ Session::when_engine_running ()
 			
 			/* default state for Click */
 
-			first_physical_output = _engine.get_nth_physical_output (0);
-			
+			first_physical_output = _engine.get_nth_physical_output (DataType::AUDIO, 0);
+
 			if (first_physical_output.length()) {
 				if (_click_io->add_output_port (first_physical_output, this)) {
 					// relax, even though its an error
@@ -742,7 +738,7 @@ Session::when_engine_running ()
 		Connection* c = new OutputConnection (buf, true);
 
 		c->add_port ();
-		c->add_connection (0, _engine.get_nth_physical_output (np));
+		c->add_connection (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
 
 		add_connection (c);
 	}
@@ -754,7 +750,7 @@ Session::when_engine_running ()
 		Connection* c = new InputConnection (buf, true);
 
 		c->add_port ();
-		c->add_connection (0, _engine.get_nth_physical_input (np));
+		c->add_connection (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
 
 		add_connection (c);
 	}
@@ -769,8 +765,8 @@ Session::when_engine_running ()
 
 		c->add_port ();
 		c->add_port ();
-		c->add_connection (0, _engine.get_nth_physical_output (np));
-		c->add_connection (1, _engine.get_nth_physical_output (np+1));
+		c->add_connection (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
+		c->add_connection (1, _engine.get_nth_physical_output (DataType::AUDIO, np+1));
 
 		add_connection (c);
 	}
@@ -783,8 +779,8 @@ Session::when_engine_running ()
 
 		c->add_port ();
 		c->add_port ();
-		c->add_connection (0, _engine.get_nth_physical_input (np));
-		c->add_connection (1, _engine.get_nth_physical_input (np+1));
+		c->add_connection (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
+		c->add_connection (1, _engine.get_nth_physical_input (DataType::AUDIO, np+1));
 
 		add_connection (c);
 	}
@@ -808,16 +804,18 @@ Session::when_engine_running ()
 			
 			_master_out->defer_pan_reset ();
 			
-			while ((int) _master_out->n_inputs() < _master_out->input_maximum()) {
-				if (_master_out->add_input_port ("", this)) {
+			while (_master_out->n_inputs().get(DataType::AUDIO)
+					< _master_out->input_maximum().get(DataType::AUDIO)) {
+				if (_master_out->add_input_port ("", this, DataType::AUDIO)) {
 					error << _("cannot setup master inputs") 
 					      << endmsg;
 					break;
 				}
 			}
 			n = 0;
-			while ((int) _master_out->n_outputs() < _master_out->output_maximum()) {
-				if (_master_out->add_output_port (_engine.get_nth_physical_output (n), this)) {
+			while (_master_out->n_outputs().get(DataType::AUDIO)
+					< _master_out->output_maximum().get(DataType::AUDIO)) {
+				if (_master_out->add_output_port (_engine.get_nth_physical_output (DataType::AUDIO, n), this, DataType::AUDIO)) {
 					error << _("cannot setup master outputs")
 					      << endmsg;
 					break;
@@ -831,7 +829,7 @@ Session::when_engine_running ()
 
 		Connection* c = new OutputConnection (_("Master Out"), true);
 
-		for (uint32_t n = 0; n < _master_out->n_inputs (); ++n) {
+		for (uint32_t n = 0; n < _master_out->n_inputs ().get_total(); ++n) {
 			c->add_port ();
 			c->add_connection ((int) n, _master_out->input(n)->name());
 		}
@@ -878,7 +876,7 @@ Session::when_engine_running ()
 
 	osc->set_session (*this);
 #endif
-    
+
 	_state_of_the_state = Clean;
 
 	DirtyChanged (); /* EMIT SIGNAL */
@@ -915,8 +913,9 @@ Session::hookup_io ()
 
 	if (_control_out) {
 		uint32_t n;
+		vector<string> cports;
 
-		while ((int) _control_out->n_inputs() < _control_out->input_maximum()) {
+		while (_control_out->n_inputs().get(DataType::AUDIO) < _control_out->input_maximum().get(DataType::AUDIO)) {
 			if (_control_out->add_input_port ("", this)) {
 				error << _("cannot setup control inputs")
 				      << endmsg;
@@ -924,15 +923,28 @@ Session::hookup_io ()
 			}
 		}
 		n = 0;
-		while ((int) _control_out->n_outputs() < _control_out->output_maximum()) {
-			if (_control_out->add_output_port (_engine.get_nth_physical_output (n), this)) {
+		while (_control_out->n_outputs().get(DataType::AUDIO) < _control_out->output_maximum().get(DataType::AUDIO)) {
+			if (_control_out->add_output_port (_engine.get_nth_physical_output (DataType::AUDIO, n), this)) {
 				error << _("cannot set up master outputs")
 				      << endmsg;
 				break;
 			}
 			n++;
 		}
-	}
+
+
+		uint32_t ni = _control_out->n_inputs().get (DataType::AUDIO);
+
+		for (n = 0; n < ni; ++n) {
+			cports.push_back (_control_out->input(n)->name());
+		}
+
+		boost::shared_ptr<RouteList> r = routes.reader ();		
+
+		for (RouteList::iterator x = r->begin(); x != r->end(); ++x) {
+			(*x)->set_control_outs (cports);
+		}
+	} 
 
 	/* Tell all IO objects to connect themselves together */
 
@@ -1216,7 +1228,7 @@ Session::enable_record ()
 	if (g_atomic_int_get (&_record_status) != Recording) {
 		g_atomic_int_set (&_record_status, Recording);
 		_last_record_location = _transport_frame;
-		send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordStrobe);
+		deliver_mmc(MIDI::MachineControl::cmdRecordStrobe, _last_record_location);
 
 		if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
 			boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
@@ -1246,7 +1258,11 @@ Session::disable_record (bool rt_context, bool force)
 			}
 		}
 
-		send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordExit);
+		// FIXME: timestamp correct? [DR]
+		// FIXME FIXME FIXME: rt_context?  this must be called in the process thread.
+		// does this /need/ to be sent in all cases?
+		if (rt_context)
+			deliver_mmc (MIDI::MachineControl::cmdRecordExit, _transport_frame);
 
 		if (Config->get_monitoring_model() == HardwareMonitoring && Config->get_auto_input()) {
 			boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
@@ -1299,7 +1315,7 @@ Session::maybe_enable_record ()
 			enable_record ();
 		} 
 	} else {
-		send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordPause);
+		deliver_mmc (MIDI::MachineControl::cmdRecordPause, _transport_frame);
 		RecordStateChanged (); /* EMIT SIGNAL */
 	}
 
@@ -1378,7 +1394,7 @@ Session::set_frame_rate (nframes_t frames_per_second)
 
 	sync_time_vars();
 
-	Route::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * 0.25));
+	Route::set_automation_interval ((nframes_t) ceil ((double) frames_per_second * 0.25));
 
 	// XXX we need some equivalent to this, somehow
 	// SndFileSource::setup_standard_crossfades (frames_per_second);
@@ -1398,39 +1414,11 @@ Session::set_block_size (nframes_t nframes)
 	*/
 
 	{ 
-		vector<Sample*>::iterator i;
-		uint32_t np;
 			
 		current_block_size = nframes;
 
-		for (np = 0, i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i, ++np) {
-			free (*i);
-		}
-
-		for (vector<Sample*>::iterator i = _silent_buffers.begin(); i != _silent_buffers.end(); ++i) {
-			free (*i);
-		}
-
-		_passthru_buffers.clear ();
-		_silent_buffers.clear ();
-
-		ensure_passthru_buffers (np);
-
-		for (vector<Sample*>::iterator i = _send_buffers.begin(); i != _send_buffers.end(); ++i) {
-			free(*i);
-
-			Sample *buf;
-#ifdef NO_POSIX_MEMALIGN
-			buf = (Sample *) malloc(current_block_size * sizeof(Sample));
-#else
-			posix_memalign((void **)&buf,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
-#endif			
-			*i = buf;
-
-			memset (*i, 0, sizeof (Sample) * current_block_size);
-		}
+		ensure_buffers(_scratch_buffers->available());
 
-		
 		if (_gain_automation_buffer) {
 			delete [] _gain_automation_buffer;
 		}
@@ -1609,17 +1597,11 @@ Session::resort_routes_using (shared_ptr<RouteList> r)
 	
 	for (i = r->begin(); i != r->end(); ++i) {
 		trace_terminal (*i, *i);
-	}	
-
+	}
+	
 	RouteSorter cmp;
 	r->sort (cmp);
 	
-	/* don't leave dangling references to routes in Route::fed_by */
-
-	for (i = r->begin(); i != r->end(); ++i) {
-		(*i)->fed_by.clear ();
-	}
-
 #if 0
 	cerr << "finished route resort\n";
 	
@@ -1631,6 +1613,86 @@ Session::resort_routes_using (shared_ptr<RouteList> r)
 	
 }
 
+list<boost::shared_ptr<MidiTrack> >
+Session::new_midi_track (TrackMode mode, uint32_t how_many)
+{
+	char track_name[32];
+	uint32_t track_id = 0;
+	uint32_t n = 0;
+	uint32_t channels_used = 0;
+	string port;
+	RouteList new_routes;
+	list<boost::shared_ptr<MidiTrack> > ret;
+
+	/* count existing midi tracks */
+
+	{
+		shared_ptr<RouteList> r = routes.reader ();
+
+		for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+			if (dynamic_cast<MidiTrack*>((*i).get()) != 0) {
+				if (!(*i)->hidden()) {
+					n++;
+					channels_used += (*i)->n_inputs().get(DataType::MIDI);
+				}
+			}
+		}
+	}
+
+	while (how_many) {
+
+		/* check for duplicate route names, since we might have pre-existing
+		   routes with this name (e.g. create Midi1, Midi2, delete Midi1,
+		   save, close,restart,add new route - first named route is now
+		   Midi2)
+		*/
+		
+
+		do {
+			++track_id;
+
+			snprintf (track_name, sizeof(track_name), "Midi %" PRIu32, track_id);
+
+			if (route_by_name (track_name) == 0) {
+				break;
+			}
+			
+		} while (track_id < (UINT_MAX-1));
+
+		try {
+			shared_ptr<MidiTrack> track (new MidiTrack (*this, track_name, Route::Flag (0), mode));
+			
+			if (track->ensure_io (ChanCount(DataType::MIDI, 1), ChanCount(DataType::MIDI, 1), false, this)) {
+				error << "cannot configure 1 in/1 out configuration for new midi track" << endmsg;
+			}
+			
+			channels_used += track->n_inputs ().get(DataType::MIDI);
+
+			track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
+			track->set_remote_control_id (ntracks());
+
+			new_routes.push_back (track);
+			ret.push_back (track);
+		}
+
+		catch (failed_constructor &err) {
+			error << _("Session: could not create new midi track.") << endmsg;
+			// XXX should we delete the tracks already created? 
+			ret.clear ();
+			return ret;
+		}
+		
+		--how_many;
+	}
+
+	if (!new_routes.empty()) {
+		add_routes (new_routes, false);
+		save_state (_current_snapshot_name);
+	}
+
+	return ret;
+}
+
 list<boost::shared_ptr<AudioTrack> >
 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, uint32_t how_many)
 {
@@ -1652,7 +1714,7 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
 			if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
 				if (!(*i)->hidden()) {
 					n++;
-					channels_used += (*i)->n_inputs();
+					channels_used += (*i)->n_inputs().get(DataType::AUDIO);
 				}
 			}
 		}
@@ -1704,7 +1766,7 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
 		try {
 			track = boost::shared_ptr<AudioTrack>((new AudioTrack (*this, track_name, Route::Flag (0), mode)));
 			
-			if (track->ensure_io (input_channels, output_channels, false, this)) {
+			if (track->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
 				error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
 							 input_channels, output_channels)
 				      << endmsg;
@@ -1712,7 +1774,7 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
 			}
 
 			if (nphysical_in) {
-				for (uint32_t x = 0; x < track->n_inputs() && x < nphysical_in; ++x) {
+				for (uint32_t x = 0; x < track->n_inputs().get(DataType::AUDIO) && x < nphysical_in; ++x) {
 					
 					port = "";
 					
@@ -1726,7 +1788,7 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
 				}
 			}
 			
-			for (uint32_t x = 0; x < track->n_outputs(); ++x) {
+			for (uint32_t x = 0; x < track->n_outputs().get(DataType::MIDI); ++x) {
 				
 				port = "";
 				
@@ -1734,7 +1796,7 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
 					port = physoutputs[(channels_used+x)%nphysical_out];
 				} else if (Config->get_output_auto_connect() & AutoConnectMaster) {
 					if (_master_out) {
-						port = _master_out->input (x%_master_out->n_inputs())->name();
+						port = _master_out->input (x%_master_out->n_inputs().get(DataType::AUDIO))->name();
 					}
 				}
 				
@@ -1743,21 +1805,8 @@ Session::new_audio_track (int input_channels, int output_channels, TrackMode mod
 				}
 			}
 			
-			channels_used += track->n_inputs ();
-
-			if (_control_out) {
-				vector<string> cports;
-				uint32_t ni = _control_out->n_inputs();
-				
-				for (n = 0; n < ni; ++n) {
-					cports.push_back (_control_out->input(n)->name());
-				}
-				
-				track->set_control_outs (cports);
-			}
+			channels_used += track->n_inputs ().get(DataType::AUDIO);
 
-			// assert (current_thread != RT_thread)
-			
 			track->audio_diskstream()->non_realtime_input_change();
 			
 			track->DiskstreamChanged.connect (mem_fun (this, &Session::resort_routes));
@@ -1872,23 +1921,25 @@ Session::new_audio_route (int input_channels, int output_channels, uint32_t how_
 		do {
 			snprintf (bus_name, sizeof(bus_name), "Bus %" PRIu32, bus_id);
 
+			bus_id++;
+
 			if (route_by_name (bus_name) == 0) {
 				break;
 			}
 
-		} while (++bus_id < (UINT_MAX-1));
+		} while (bus_id < (UINT_MAX-1));
 
 		try {
 			shared_ptr<Route> bus (new Route (*this, bus_name, -1, -1, -1, -1, Route::Flag(0), DataType::AUDIO));
 			
-			if (bus->ensure_io (input_channels, output_channels, false, this)) {
+			if (bus->ensure_io (ChanCount(DataType::AUDIO, input_channels), ChanCount(DataType::AUDIO, output_channels), false, this)) {
 				error << string_compose (_("cannot configure %1 in/%2 out configuration for new audio track"),
 							 input_channels, output_channels)
 				      << endmsg;
 				goto failure;
 			}
 			
-			for (uint32_t x = 0; n_physical_inputs && x < bus->n_inputs(); ++x) {
+			for (uint32_t x = 0; n_physical_inputs && x < bus->n_inputs().get(DataType::AUDIO); ++x) {
 				
 				port = "";
 
@@ -1901,7 +1952,7 @@ Session::new_audio_route (int input_channels, int output_channels, uint32_t how_
 				}
 			}
 			
-			for (uint32_t x = 0; n_physical_outputs && x < bus->n_outputs(); ++x) {
+			for (uint32_t x = 0; n_physical_outputs && x < bus->n_outputs().get(DataType::AUDIO); ++x) {
 				
 				port = "";
 				
@@ -1909,7 +1960,7 @@ Session::new_audio_route (int input_channels, int output_channels, uint32_t how_
 					port = physoutputs[((n+x)%n_physical_outputs)];
 				} else if (Config->get_output_auto_connect() & AutoConnectMaster) {
 					if (_master_out) {
-						port = _master_out->input (x%_master_out->n_inputs())->name();
+						port = _master_out->input (x%_master_out->n_inputs().get(DataType::AUDIO))->name();
 					}
 				}
 				
@@ -1918,16 +1969,6 @@ Session::new_audio_route (int input_channels, int output_channels, uint32_t how_
 				}
 			}
 			
-			if (_control_out) {
-				vector<string> cports;
-				uint32_t ni = _control_out->n_inputs();
-				
-				for (uint32_t n = 0; n < ni; ++n) {
-					cports.push_back (_control_out->input(n)->name());
-				}
-				bus->set_control_outs (cports);
-			}
-
 			bus->set_remote_control_id (control_id);
 			++control_id;
 
@@ -1984,9 +2025,23 @@ Session::add_routes (RouteList& new_routes, bool save)
 		
 		if ((*x)->control()) {
 			_control_out = (*x);
-		}
+		} 
 	}
 
+	if (_control_out && IO::connecting_legal) {
+
+		vector<string> cports;
+		uint32_t ni = _control_out->n_inputs().get(DataType::AUDIO);
+
+		for (uint32_t n = 0; n < ni; ++n) {
+			cports.push_back (_control_out->input(n)->name());
+		}
+
+		for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
+			(*x)->set_control_outs (cports);
+		}
+	} 
+
 	set_dirty();
 
 	if (save) {
@@ -2054,12 +2109,11 @@ Session::remove_route (shared_ptr<Route> route)
 		/* writer goes out of scope, forces route list update */
 	}
 
-	// FIXME: audio specific
-	AudioTrack* at;
-	boost::shared_ptr<AudioDiskstream> ds;
+	Track* t;
+	boost::shared_ptr<Diskstream> ds;
 	
-	if ((at = dynamic_cast<AudioTrack*>(route.get())) != 0) {
-		ds = at->audio_diskstream();
+	if ((t = dynamic_cast<Track*>(route.get())) != 0) {
+		ds = t->diskstream();
 	}
 	
 	if (ds) {
@@ -2132,7 +2186,7 @@ Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
 			
 			/* don't mess with busses */
 			
-			if (dynamic_cast<AudioTrack*>((*i).get()) == 0) {
+			if (dynamic_cast<Track*>((*i).get()) == 0) {
 				continue;
 			}
 			
@@ -2140,7 +2194,7 @@ Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
 			
 			/* don't mess with tracks */
 			
-			if (dynamic_cast<AudioTrack*>((*i).get()) != 0) {
+			if (dynamic_cast<Track*>((*i).get()) != 0) {
 				continue;
 			}
 		}
@@ -2176,7 +2230,7 @@ Session::route_solo_changed (void* src, boost::weak_ptr<Route> wpr)
         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 		if ((*i)->soloed()) {
 			something_soloed = true;
-			if (dynamic_cast<AudioTrack*>((*i).get())) {
+			if (dynamic_cast<Track*>((*i).get())) {
 				if (is_track) {
 					same_thing_soloed = true;
 					break;
@@ -2225,7 +2279,7 @@ Session::update_route_solo_state ()
         for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 		if ((*i)->soloed()) {
 			mute = true;
-			if (dynamic_cast<AudioTrack*>((*i).get())) {
+			if (dynamic_cast<Track*>((*i).get())) {
 				is_track = true;
 			}
 			break;
@@ -2270,7 +2324,7 @@ Session::modify_solo_mute (bool is_track, bool mute)
 			
 			/* only alter track solo mute */
 			
-			if (dynamic_cast<AudioTrack*>((*i).get())) {
+			if (dynamic_cast<Track*>((*i).get())) {
 				if ((*i)->soloed()) {
 					(*i)->set_solo_mute (!mute);
 				} else {
@@ -2282,7 +2336,7 @@ Session::modify_solo_mute (bool is_track, bool mute)
 
 			/* only alter bus solo mute */
 
-			if (!dynamic_cast<AudioTrack*>((*i).get())) {
+			if (!dynamic_cast<Track*>((*i).get())) {
 
 				if ((*i)->soloed()) {
 
@@ -2421,7 +2475,7 @@ Session::diskstream_by_id (const PBD::ID& id)
 	return boost::shared_ptr<Diskstream>((Diskstream*) 0);
 }
 
-/* AudioRegion management */
+/* Region management */
 
 string
 Session::new_region_name (string old)
@@ -2447,7 +2501,7 @@ Session::new_region_name (string old)
 
 	while (number < (UINT_MAX-1)) {
 
-		AudioRegionList::const_iterator i;
+		RegionList::const_iterator i;
 		string sbuf;
 
 		number++;
@@ -2455,13 +2509,13 @@ Session::new_region_name (string old)
 		snprintf (buf, len, "%s%" PRIu32, old.substr (0, last_period + 1).c_str(), number);
 		sbuf = buf;
 
-		for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
+		for (i = regions.begin(); i != regions.end(); ++i) {
 			if (i->second->name() == sbuf) {
 				break;
 			}
 		}
 		
-		if (i == audio_regions.end()) {
+		if (i == regions.end()) {
 			break;
 		}
 	}
@@ -2480,11 +2534,13 @@ Session::region_name (string& result, string base, bool newlevel) const
 	char buf[16];
 	string subbase;
 
+	assert(base.find("/") == string::npos);
+
 	if (base == "") {
 		
 		Glib::Mutex::Lock lm (region_lock);
 
-		snprintf (buf, sizeof (buf), "%d", (int)audio_regions.size() + 1);
+		snprintf (buf, sizeof (buf), "%d", (int)regions.size() + 1);
 
 		
 		result = "region.";
@@ -2520,7 +2576,7 @@ Session::region_name (string& result, string base, bool newlevel) const
 				
 				name_taken = false;
 				
-				for (AudioRegionList::const_iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
+				for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
 					if (i->second->name() == result) {
 						name_taken = true;
 						break;
@@ -2544,51 +2600,40 @@ Session::region_name (string& result, string base, bool newlevel) const
 void
 Session::add_region (boost::shared_ptr<Region> region)
 {
-	boost::shared_ptr<AudioRegion> ar;
-	boost::shared_ptr<AudioRegion> oar;
+	boost::shared_ptr<Region> other;
 	bool added = false;
 
 	{ 
 		Glib::Mutex::Lock lm (region_lock);
 
-		if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
+		RegionList::iterator x;
 
-			AudioRegionList::iterator x;
+		for (x = regions.begin(); x != regions.end(); ++x) {
 
-			for (x = audio_regions.begin(); x != audio_regions.end(); ++x) {
+			other = x->second;
 
-				oar = boost::dynamic_pointer_cast<AudioRegion> (x->second);
-
-				if (ar->region_list_equivalent (oar)) {
-					break;
-				}
+			if (region->region_list_equivalent (other)) {
+				break;
 			}
+		}
 
-			if (x == audio_regions.end()) {
-
-				pair<AudioRegionList::key_type,AudioRegionList::mapped_type> entry;
+		if (x == regions.end()) {
 
-				entry.first = region->id();
-				entry.second = ar;
+			pair<RegionList::key_type,RegionList::mapped_type> entry;
 
-				pair<AudioRegionList::iterator,bool> x = audio_regions.insert (entry);
+			entry.first = region->id();
+			entry.second = region;
 
-				
-				if (!x.second) {
-					return;
-				}
+			pair<RegionList::iterator,bool> x = regions.insert (entry);
 
-				added = true;
-			} 
 
-		} else {
+			if (!x.second) {
+				return;
+			}
 
-			fatal << _("programming error: ")
-			      << X_("unknown region type passed to Session::add_region()")
-			      << endmsg;
-			/*NOTREACHED*/
+			added = true;
+		} 
 
-		}
 	}
 
 	/* mark dirty because something has changed even if we didn't
@@ -2600,7 +2645,7 @@ Session::add_region (boost::shared_ptr<Region> region)
 	if (added) {
 		region->GoingAway.connect (sigc::bind (mem_fun (*this, &Session::remove_region), boost::weak_ptr<Region>(region)));
 		region->StateChanged.connect (sigc::bind (mem_fun (*this, &Session::region_changed), boost::weak_ptr<Region>(region)));
-		AudioRegionAdded (ar); /* EMIT SIGNAL */
+		RegionAdded (region); /* EMIT SIGNAL */
 	}
 }
 
@@ -2622,31 +2667,21 @@ Session::region_changed (Change what_changed, boost::weak_ptr<Region> weak_regio
 void
 Session::remove_region (boost::weak_ptr<Region> weak_region)
 {
-	AudioRegionList::iterator i;
+	RegionList::iterator i;
 	boost::shared_ptr<Region> region (weak_region.lock ());
 
 	if (!region) {
 		return;
 	}
 
-	boost::shared_ptr<AudioRegion> ar;
 	bool removed = false;
 
 	{ 
 		Glib::Mutex::Lock lm (region_lock);
 
- 		if ((ar = boost::dynamic_pointer_cast<AudioRegion> (region)) != 0) {
-			if ((i = audio_regions.find (region->id())) != audio_regions.end()) {
-				audio_regions.erase (i);
-				removed = true;
-			}
-
-		} else {
-
-			fatal << _("programming error: ") 
-			      << X_("unknown region type passed to Session::remove_region()")
-			      << endmsg;
-			/*NOTREACHED*/
+		if ((i = regions.find (region->id())) != regions.end()) {
+			regions.erase (i);
+			removed = true;
 		}
 	}
 
@@ -2657,18 +2692,19 @@ Session::remove_region (boost::weak_ptr<Region> weak_region)
 	set_dirty();
 
 	if (removed) {
-		AudioRegionRemoved (ar); /* EMIT SIGNAL */
+		 RegionRemoved(region); /* EMIT SIGNAL */
 	}
 }
 
-boost::shared_ptr<AudioRegion>
-Session::find_whole_file_parent (boost::shared_ptr<AudioRegion const> child)
+boost::shared_ptr<Region>
+Session::find_whole_file_parent (boost::shared_ptr<Region const> child)
 {
-	AudioRegionList::iterator i;
-	boost::shared_ptr<AudioRegion> region;
+	RegionList::iterator i;
+	boost::shared_ptr<Region> region;
+	
 	Glib::Mutex::Lock lm (region_lock);
 
-	for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
+	for (i = regions.begin(); i != regions.end(); ++i) {
 
 		region = i->second;
 
@@ -2680,7 +2716,7 @@ Session::find_whole_file_parent (boost::shared_ptr<AudioRegion const> child)
 		}
 	} 
 
-	return boost::shared_ptr<AudioRegion> ();
+	return boost::shared_ptr<Region> ();
 }	
 
 void
@@ -2771,37 +2807,30 @@ Session::remove_region_from_region_list (boost::shared_ptr<Region> r)
 }
 
 /* Source Management */
-
 void
 Session::add_source (boost::shared_ptr<Source> source)
 {
-	boost::shared_ptr<AudioFileSource> afs;
-
-	if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
-
-		pair<AudioSourceList::key_type, AudioSourceList::mapped_type> entry;
-		pair<AudioSourceList::iterator,bool> result;
+	pair<SourceMap::key_type, SourceMap::mapped_type> entry;
+	pair<SourceMap::iterator,bool> result;
 
-		entry.first = source->id();
-		entry.second = afs;
-		
-		{
-			Glib::Mutex::Lock lm (audio_source_lock);
-			result = audio_sources.insert (entry);
-		}
-
-		if (result.second) {
-			source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
-			set_dirty();
-		}
+	entry.first = source->id();
+	entry.second = source;
+	
+	{
+		Glib::Mutex::Lock lm (source_lock);
+		result = sources.insert (entry);
+	}
 
-	} 
+	if (result.second) {
+		source->GoingAway.connect (sigc::bind (mem_fun (this, &Session::remove_source), boost::weak_ptr<Source> (source)));
+		set_dirty();
+	}
 }
 
 void
 Session::remove_source (boost::weak_ptr<Source> src)
 {
-	AudioSourceList::iterator i;
+	SourceMap::iterator i;
 	boost::shared_ptr<Source> source = src.lock();
 
 	if (!source) {
@@ -2809,11 +2838,15 @@ Session::remove_source (boost::weak_ptr<Source> src)
 	} 
 
 	{ 
-		Glib::Mutex::Lock lm (audio_source_lock);
+		Glib::Mutex::Lock lm (source_lock);
 		
-		if ((i = audio_sources.find (source->id())) != audio_sources.end()) {
-			audio_sources.erase (i);
-		} 
+		{ 
+			Glib::Mutex::Lock lm (source_lock);
+			
+			if ((i = sources.find (source->id())) != sources.end()) {
+				sources.erase (i);
+			} 
+		}
 	}
 	
 	if (!_state_of_the_state & InCleanup) {
@@ -2829,11 +2862,11 @@ Session::remove_source (boost::weak_ptr<Source> src)
 boost::shared_ptr<Source>
 Session::source_by_id (const PBD::ID& id)
 {
-	Glib::Mutex::Lock lm (audio_source_lock);
-	AudioSourceList::iterator i;
+	Glib::Mutex::Lock lm (source_lock);
+	SourceMap::iterator i;
 	boost::shared_ptr<Source> source;
 
-	if ((i = audio_sources.find (id)) != audio_sources.end()) {
+	if ((i = sources.find (id)) != sources.end()) {
 		source = i->second;
 	}
 
@@ -2846,9 +2879,9 @@ Session::source_by_id (const PBD::ID& id)
 boost::shared_ptr<Source>
 Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
 {
-	Glib::Mutex::Lock lm (audio_source_lock);
+	Glib::Mutex::Lock lm (source_lock);
 
-	for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
+	for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
 		cerr << "comparing " << path << " with " << i->second->name() << endl;
 		boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
 
@@ -3088,10 +3121,201 @@ Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool
 boost::shared_ptr<AudioFileSource>
 Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
 {
-	string spath = audio_path_from_name (ds.name(), ds.n_channels(), chan, destructive);
-	return boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, spath, destructive, frame_rate()));
+	string spath = audio_path_from_name (ds.name(), ds.n_channels().get(DataType::AUDIO), chan, destructive);
+	return boost::dynamic_pointer_cast<AudioFileSource> (
+		SourceFactory::createWritable (DataType::AUDIO, *this, spath, destructive, frame_rate()));
+}
+
+// FIXME: _terrible_ code duplication
+string
+Session::change_midi_path_by_name (string path, string oldname, string newname, bool destructive)
+{
+	string look_for;
+	string old_basename = PBD::basename_nosuffix (oldname);
+	string new_legalized = legalize_for_path (newname);
+
+	/* note: we know (or assume) the old path is already valid */
+
+	if (destructive) {
+		
+		/* destructive file sources have a name of the form:
+
+		    /path/to/Tnnnn-NAME(%[LR])?.wav
+		  
+		    the task here is to replace NAME with the new name.
+		*/
+		
+		/* find last slash */
+
+		string dir;
+		string prefix;
+		string::size_type slash;
+		string::size_type dash;
+
+		if ((slash = path.find_last_of ('/')) == string::npos) {
+			return "";
+		}
+
+		dir = path.substr (0, slash+1);
+
+		/* '-' is not a legal character for the NAME part of the path */
+
+		if ((dash = path.find_last_of ('-')) == string::npos) {
+			return "";
+		}
+
+		prefix = path.substr (slash+1, dash-(slash+1));
+
+		path = dir;
+		path += prefix;
+		path += '-';
+		path += new_legalized;
+		path += ".mid";  /* XXX gag me with a spoon */
+		
+	} else {
+		
+		/* non-destructive file sources have a name of the form:
+
+		    /path/to/NAME-nnnnn(%[LR])?.wav
+		  
+		    the task here is to replace NAME with the new name.
+		*/
+		
+		string dir;
+		string suffix;
+		string::size_type slash;
+		string::size_type dash;
+		string::size_type postfix;
+
+		/* find last slash */
+
+		if ((slash = path.find_last_of ('/')) == string::npos) {
+			return "";
+		}
+
+		dir = path.substr (0, slash+1);
+
+		/* '-' is not a legal character for the NAME part of the path */
+
+		if ((dash = path.find_last_of ('-')) == string::npos) {
+			return "";
+		}
+
+		suffix = path.substr (dash+1);
+		
+		// Suffix is now everything after the dash. Now we need to eliminate
+		// the nnnnn part, which is done by either finding a '%' or a '.'
+
+		postfix = suffix.find_last_of ("%");
+		if (postfix == string::npos) {
+			postfix = suffix.find_last_of ('.');
+		}
+
+		if (postfix != string::npos) {
+			suffix = suffix.substr (postfix);
+		} else {
+			error << "Logic error in Session::change_midi_path_by_name(), please report to the developers" << endl;
+			return "";
+		}
+
+		const uint32_t limit = 10000;
+		char buf[PATH_MAX+1];
+
+		for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
+
+			snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
+
+			if (access (buf, F_OK) != 0) {
+				path = buf;
+				break;
+			}
+			path = "";
+		}
+
+		if (path == "") {
+			error << "FATAL ERROR! Could not find a " << endl;
+		}
+
+	}
+
+	return path;
+}
+
+string
+Session::midi_path_from_name (string name)
+{
+	string spath;
+	uint32_t cnt;
+	char buf[PATH_MAX+1];
+	const uint32_t limit = 10000;
+	string legalized;
+
+	buf[0] = '\0';
+	legalized = legalize_for_path (name);
+
+	/* find a "version" of the file name that doesn't exist in
+	   any of the possible directories.
+	*/
+
+	for (cnt = 1; cnt <= limit; ++cnt) {
+
+		vector<space_and_path>::iterator i;
+		uint32_t existing = 0;
+
+		for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
+
+			spath = (*i).path;
+
+			// FIXME: different directory from audio?
+			spath += sound_dir(false) + "/" + legalized;
+
+			snprintf (buf, sizeof(buf), "%s-%u.mid", spath.c_str(), cnt);
+
+			if (g_file_test (buf, G_FILE_TEST_EXISTS)) {
+				existing++;
+			} 
+		}
+
+		if (existing == 0) {
+			break;
+		}
+
+		if (cnt > limit) {
+			error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
+			throw failed_constructor();
+		}
+	}
+
+	/* we now have a unique name for the file, but figure out where to
+	   actually put it.
+	*/
+
+	string foo = buf;
+
+	// FIXME: different directory than audio?
+	spath = discover_best_sound_dir ();
+	spath += '/';
+
+	string::size_type pos = foo.find_last_of ('/');
+	
+	if (pos == string::npos) {
+		spath += foo;
+	} else {
+		spath += foo.substr (pos + 1);
+	}
+
+	return spath;
+}
+
+boost::shared_ptr<MidiSource>
+Session::create_midi_source_for_session (MidiDiskstream& ds)
+{
+	string spath = midi_path_from_name (ds.name());
+	
+	return boost::dynamic_pointer_cast<SMFSource> (SourceFactory::createWritable (DataType::MIDI, *this, spath, false, frame_rate()));
 }
 
+
 /* Playlist management */
 
 boost::shared_ptr<Playlist>
@@ -3279,7 +3503,7 @@ Session::remove_empty_sounds ()
 
 	vector<string *>* possible_audiofiles = scanner (sound_dir(), "\\.(wav|aiff|caf|w64)$", false, true);
 	
-	Glib::Mutex::Lock lm (audio_source_lock);
+	Glib::Mutex::Lock lm (source_lock);
 	
 	regex_t compiled_tape_track_pattern;
 	int err;
@@ -3381,7 +3605,7 @@ Session::graph_reordered ()
 	if (_state_of_the_state & InitialConnecting) {
 		return;
 	}
-
+	
 	/* every track/bus asked for this to be handled but it was deferred because
 	   we were connecting. do it now.
 	*/
@@ -3419,9 +3643,9 @@ Session::record_enable_change_all (bool yn)
 	shared_ptr<RouteList> r = routes.reader ();
 	
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-		AudioTrack* at;
+		Track* at;
 
-		if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
+		if ((at = dynamic_cast<Track*>((*i).get())) != 0) {
 			at->set_record_enable (yn, this);
 		}
 	}
@@ -3582,40 +3806,18 @@ Session::tempo_map_changed (Change ignored)
 	set_dirty ();
 }
 
+/** Ensures that all buffers (scratch, send, silent, etc) are allocated for
+ * the given count with the current block size.
+ */
 void
-Session::ensure_passthru_buffers (uint32_t howmany)
+Session::ensure_buffers (ChanCount howmany)
 {
-	while (howmany > _passthru_buffers.size()) {
-		Sample *p;
-#ifdef NO_POSIX_MEMALIGN
-		p =  (Sample *) malloc(current_block_size * sizeof(Sample));
-#else
-		posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
-#endif			
-		_passthru_buffers.push_back (p);
-
-		*p = 0;
-		
-#ifdef NO_POSIX_MEMALIGN
-		p =  (Sample *) malloc(current_block_size * sizeof(Sample));
-#else
-		posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * 4);
-#endif			
-		memset (p, 0, sizeof (Sample) * current_block_size);
-		_silent_buffers.push_back (p);
-
-		*p = 0;
-		
-#ifdef NO_POSIX_MEMALIGN
-		p =  (Sample *) malloc(current_block_size * sizeof(Sample));
-#else
-		posix_memalign((void **)&p,CPU_CACHE_ALIGN,current_block_size * sizeof(Sample));
-#endif			
-		memset (p, 0, sizeof (Sample) * current_block_size);
-		_send_buffers.push_back (p);
-		
-	}
-	allocate_pan_automation_buffers (current_block_size, howmany, false);
+	// FIXME: NASTY assumption (midi block size == audio block size)
+	_scratch_buffers->ensure_buffers(howmany, current_block_size);
+	_send_buffers->ensure_buffers(howmany, current_block_size);
+	_silent_buffers->ensure_buffers(howmany, current_block_size);
+	
+	allocate_pan_automation_buffers (current_block_size, howmany.get(DataType::AUDIO), false);
 }
 
 uint32_t
@@ -3799,9 +4001,9 @@ Session::freeze (InterThreadInfo& itt)
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
-		AudioTrack *at;
+		Track *at;
 
-		if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
+		if ((at = dynamic_cast<Track*>((*i).get())) != 0) {
 			/* XXX this is wrong because itt.progress will keep returning to zero at the start
 			   of every track.
 			*/
@@ -3814,7 +4016,7 @@ Session::freeze (InterThreadInfo& itt)
 
 int
 Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t len, 	
-			       bool overwrite, vector<boost::shared_ptr<AudioSource> >& srcs, InterThreadInfo& itt)
+			       bool overwrite, vector<boost::shared_ptr<Source> >& srcs, InterThreadInfo& itt)
 {
 	int ret = -1;
 	boost::shared_ptr<Playlist> playlist;
@@ -3822,11 +4024,11 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 	uint32_t x;
 	char buf[PATH_MAX+1];
 	string dir;
-	uint32_t nchans;
+	ChanCount nchans(track.audio_diskstream()->n_channels());
 	nframes_t position;
 	nframes_t this_chunk;
 	nframes_t to_do;
-	vector<Sample*> buffers;
+	BufferSet buffers;
 
 	// any bigger than this seems to cause stack overflows in called functions
 	const nframes_t chunk_size = (128 * 1024)/4;
@@ -3844,12 +4046,10 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 	if (track.has_external_redirects()) {
 		goto out;
 	}
-
-	nchans = track.audio_diskstream()->n_channels();
 	
 	dir = discover_best_sound_dir ();
 
-	for (uint32_t chan_n=0; chan_n < nchans; ++chan_n) {
+	for (uint32_t chan_n=0; chan_n < nchans.get(DataType::AUDIO); ++chan_n) {
 
 		for (x = 0; x < 99999; ++x) {
 			snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 ".wav", dir.c_str(), playlist->name().c_str(), chan_n, x+1);
@@ -3864,7 +4064,8 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 		}
 		
 		try {
-			fsource = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, buf, false, frame_rate()));
+			fsource = boost::dynamic_pointer_cast<AudioFileSource> (
+				SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
 		}
 		
 		catch (failed_constructor& err) {
@@ -3881,35 +4082,29 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 	to_do = len;
 
 	/* create a set of reasonably-sized buffers */
+	buffers.ensure_buffers(nchans, chunk_size);
+	buffers.set_count(nchans);
 
-	for (vector<Sample*>::iterator i = _passthru_buffers.begin(); i != _passthru_buffers.end(); ++i) {
-		Sample* b;
-#ifdef NO_POSIX_MEMALIGN
-		b =  (Sample *) malloc(chunk_size * sizeof(Sample));
-#else
-		posix_memalign((void **)&b,4096,chunk_size * sizeof(Sample));
-#endif			
-		buffers.push_back (b);
-	}
-
-	for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
-		(*src)->prepare_for_peakfile_writes ();
+	for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
+		boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
+		if (afs)
+			afs->prepare_for_peakfile_writes ();
 	}
 			
 	while (to_do && !itt.cancel) {
 		
 		this_chunk = min (to_do, chunk_size);
 		
-		if (track.export_stuff (buffers, nchans, start, this_chunk)) {
+		if (track.export_stuff (buffers, start, this_chunk)) {
 			goto out;
 		}
 
 		uint32_t n = 0;
-		for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
+		for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
 			boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
 			
 			if (afs) {
-				if (afs->write (buffers[n], this_chunk) != this_chunk) {
+				if (afs->write (buffers.get_audio(n).data(), this_chunk) != this_chunk) {
 					goto out;
 				}
 			}
@@ -3929,9 +4124,9 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 		time (&now);
 		xnow = localtime (&now);
 		
-		for (vector<boost::shared_ptr<AudioSource> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
+		for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
 			boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
-
+			
 			if (afs) {
 				afs->update_header (position, *xnow, now);
 				afs->flush_header ();
@@ -3948,7 +4143,7 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 		
   out:
 	if (ret) {
-		for (vector<boost::shared_ptr<AudioSource> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
+		for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
 			boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
 
 			if (afs) {
@@ -3959,15 +4154,14 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 		}
 
 	} else {
-		for (vector<boost::shared_ptr<AudioSource> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
-			(*src)->done_with_peakfile_writes ();
+		for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
+			boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
+			
+			if (afs)
+				afs->done_with_peakfile_writes ();
 		}
 	}
 
-	for (vector<Sample*>::iterator i = buffers.begin(); i != buffers.end(); ++i) {
-		free(*i);
-	}
-
 	g_atomic_int_set (&processing_prohibited, 0);
 
 	itt.done = true;
@@ -3975,13 +4169,35 @@ Session::write_one_audio_track (AudioTrack& track, nframes_t start, nframes_t le
 	return ret;
 }
 
-vector<Sample*>&
-Session::get_silent_buffers (uint32_t howmany)
+BufferSet&
+Session::get_silent_buffers (ChanCount count)
 {
-	for (uint32_t i = 0; i < howmany; ++i) {
-		memset (_silent_buffers[i], 0, sizeof (Sample) * current_block_size);
+	assert(_silent_buffers->available() >= count);
+	_silent_buffers->set_count(count);
+
+	for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+		for (size_t i=0; i < count.get(*t); ++i) {
+			_silent_buffers->get(*t, i).clear();
+		}
 	}
-	return _silent_buffers;
+	
+	return *_silent_buffers;
+}
+
+BufferSet&
+Session::get_scratch_buffers (ChanCount count)
+{
+	assert(_scratch_buffers->available() >= count);
+	_scratch_buffers->set_count(count);
+	return *_scratch_buffers;
+}
+
+BufferSet&
+Session::get_send_buffers (ChanCount count)
+{
+	assert(_send_buffers->available() >= count);
+	_send_buffers->set_count(count);
+	return *_send_buffers;
 }
 
 uint32_t 
@@ -3991,7 +4207,7 @@ Session::ntracks () const
 	shared_ptr<RouteList> r = routes.reader ();
 
 	for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
-		if (dynamic_cast<AudioTrack*> ((*i).get())) {
+		if (dynamic_cast<Track*> ((*i).get())) {
 			++n;
 		}
 	}
@@ -4006,7 +4222,7 @@ Session::nbusses () const
 	shared_ptr<RouteList> r = routes.reader ();
 
 	for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
-		if (dynamic_cast<AudioTrack*> ((*i).get()) == 0) {
+		if (dynamic_cast<Track*> ((*i).get()) == 0) {
 			++n;
 		}
 	}
diff --git a/libs/ardour/session_click.cc b/libs/ardour/session_click.cc
index f2064ab731..fb51f22564 100644
--- a/libs/ardour/session_click.cc
+++ b/libs/ardour/session_click.cc
@@ -24,6 +24,7 @@
 #include <ardour/session.h>
 #include <ardour/tempo.h>
 #include <ardour/io.h>
+#include <ardour/buffer_set.h>
 
 #include <sndfile.h>
 
@@ -39,9 +40,7 @@ void
 Session::click (nframes_t start, nframes_t nframes, nframes_t offset)
 {
 	TempoMap::BBTPointList *points;
-	nframes_t end;
 	Sample *buf;
-	vector<Sample*> bufs;
 
 	if (_click_io == 0) {
 		return;
@@ -54,38 +53,38 @@ Session::click (nframes_t start, nframes_t nframes, nframes_t offset)
 		return;
 	} 
 
-	end = start + nframes;
+	const nframes_t end = start + (nframes_t)floor(nframes * _transport_speed);
 
-	buf = _passthru_buffers[0];
+	BufferSet& bufs = get_scratch_buffers(ChanCount(DataType::AUDIO, 1));
+	buf = bufs.get_audio(0).data();
 	points = _tempo_map->get_points (start, end);
 
 	if (points == 0) {
 		goto run_clicks;
 	}
 
-	if (!points->empty()) {
-
-		for (TempoMap::BBTPointList::iterator i = points->begin(); i != points->end(); ++i) {
-			switch ((*i).type) {
-			case TempoMap::Beat:
-				if (click_emphasis_data == 0 || (click_emphasis_data && (*i).beat != 1)) {
-					clicks.push_back (new Click ((*i).frame, click_length, click_data));
-				}
-				break;
-				
-			case TempoMap::Bar:
-				if (click_emphasis_data) {
-					clicks.push_back (new Click ((*i).frame, click_emphasis_length, click_emphasis_data));
-				} 
-				break;
+	if (points->empty()) {
+		delete points;
+		goto run_clicks;
+	}
+
+	for (TempoMap::BBTPointList::iterator i = points->begin(); i != points->end(); ++i) {
+		switch ((*i).type) {
+		case TempoMap::Beat:
+			if (click_emphasis_data == 0 || (click_emphasis_data && (*i).beat != 1)) {
+				clicks.push_back (new Click ((*i).frame, click_length, click_data));
 			}
+			break;
+
+		case TempoMap::Bar:
+			if (click_emphasis_data) {
+				clicks.push_back (new Click ((*i).frame, click_emphasis_length, click_emphasis_data));
+			} 
+			break;
 		}
 	}
 	
-	delete points;
-	
   run_clicks:
-	
 	memset (buf, 0, sizeof (Sample) * nframes);
 
 	for (list<Click*>::iterator i = clicks.begin(); i != clicks.end(); ) {
@@ -126,8 +125,8 @@ Session::click (nframes_t start, nframes_t nframes, nframes_t offset)
 
 		i = next;
 	}
-
-	_click_io->deliver_output (_passthru_buffers, 1, nframes, offset);
+	
+	_click_io->deliver_output (bufs, start, end, nframes, offset);
 }
 
 void
diff --git a/libs/ardour/session_command.cc b/libs/ardour/session_command.cc
index b9a0e2cb60..10f319ace8 100644
--- a/libs/ardour/session_command.cc
+++ b/libs/ardour/session_command.cc
@@ -27,6 +27,8 @@
 #include <ardour/tempo.h>
 #include <ardour/audiosource.h>
 #include <ardour/audioregion.h>
+#include <ardour/midi_source.h>
+#include <ardour/midi_region.h>
 #include <pbd/error.h>
 #include <pbd/id.h>
 #include <pbd/statefuldestructible.h>
@@ -78,13 +80,13 @@ Session::memento_command_factory(XMLNode *n)
 
     /* create command */
     string obj_T = n->property ("type_name")->value();
-    if (obj_T == typeid (AudioRegion).name() || obj_T == typeid (Region).name()) {
-	    if (audio_regions.count(id)) {
-		    return new MementoCommand<AudioRegion>(*audio_regions[id], before, after);
+    if (obj_T == typeid (AudioRegion).name() || obj_T == typeid (MidiRegion).name() || obj_T == typeid (Region).name()) {
+	    if (regions.count(id)) {
+		    return new MementoCommand<Region>(*regions[id], before, after);
 	    }
-    } else if (obj_T == typeid (AudioSource).name()) {
-	    if (audio_sources.count(id))
-		    return new MementoCommand<AudioSource>(*audio_sources[id], before, after);
+    } else if (obj_T == typeid (AudioSource).name() || obj_T == typeid (MidiSource).name()) {
+	    if (sources.count(id))
+		    return new MementoCommand<Source>(*sources[id], before, after);
     } else if (obj_T == typeid (Location).name()) {
 	    return new MementoCommand<Location>(*_locations.get_location_by_id(id), before, after);
     } else if (obj_T == typeid (Locations).name()) {
diff --git a/libs/ardour/session_events.cc b/libs/ardour/session_events.cc
index e93a7a5f17..35c1019c0e 100644
--- a/libs/ardour/session_events.cc
+++ b/libs/ardour/session_events.cc
@@ -170,10 +170,10 @@ Session::merge_event (Event* ev)
 	set_next_event ();
 }
 
+/** @return true when @a ev is deleted. */
 bool
 Session::_replace_event (Event* ev)
 {
-	// returns true when we deleted the passed in event
 	bool ret = false;
 	Events::iterator i;
 
@@ -202,10 +202,10 @@ Session::_replace_event (Event* ev)
 	return ret;
 }
 
+/** @return true when @a ev is deleted. */
 bool
 Session::_remove_event (Session::Event* ev)
 {
-	// returns true when we deleted the passed in event
 	bool ret = false;
 	Events::iterator i;
 	
@@ -314,6 +314,8 @@ Session::process_event (Event* ev)
 		}
 	}
 
+	//printf("Processing event: %s\n", event_names[ev->type]);
+
 	switch (ev->type) {
 	case Event::SetLoop:
 		set_play_loop (ev->yes_or_no);
@@ -335,6 +337,7 @@ Session::process_event (Event* ev)
 			// cerr << "soft locate to " << ev->target_frame << endl;
 			start_locate (ev->target_frame, false, true, false);
 		}
+		_send_smpte_update = true;
 		break;
 
 	case Event::LocateRoll:
@@ -345,6 +348,7 @@ Session::process_event (Event* ev)
 			// cerr << "soft locate to+roll " << ev->target_frame << endl;
 			start_locate (ev->target_frame, true, true, false);
 		}
+		_send_smpte_update = true;
 		break;
 
 	case Event::SetTransportSpeed:
@@ -397,7 +401,7 @@ Session::process_event (Event* ev)
 		break;
 
 	case Event::SetDiskstreamSpeed:
-		set_diskstream_speed (static_cast<AudioDiskstream*> (ev->ptr), ev->speed);
+		set_diskstream_speed (static_cast<Diskstream*> (ev->ptr), ev->speed);
 		break;
 
 	case Event::SetSlaveSource:
diff --git a/libs/ardour/session_export.cc b/libs/ardour/session_export.cc
index 87bf5a5b03..b0addd21f6 100644
--- a/libs/ardour/session_export.cc
+++ b/libs/ardour/session_export.cc
@@ -45,6 +45,7 @@
 #include <ardour/export.h>
 #include <ardour/sndfile_helpers.h>
 #include <ardour/port.h>
+#include <ardour/audio_port.h>
 #include <ardour/audioengine.h>
 #include <ardour/audio_diskstream.h>
 #include <ardour/panner.h>
@@ -583,8 +584,12 @@ Session::process_export (nframes_t nframes, AudioExportSpecification* spec)
 			/* OK, this port's output is supposed to appear on this channel 
 			 */
 
-			Port* port = (*t).first;
-			Sample* port_buffer = port->get_buffer (nframes);
+			AudioPort* const port = dynamic_cast<AudioPort*>((*t).first);
+			if (port == 0) {
+				cerr << "FIXME: Non-audio export" << endl;
+				continue;
+			}
+			Sample* port_buffer = port->get_audio_buffer().data();
 
 			/* now interleave the data from the channel into the float buffer */
 				
diff --git a/libs/ardour/session_midi.cc b/libs/ardour/session_midi.cc
index f58098d9d1..7f88766b63 100644
--- a/libs/ardour/session_midi.cc
+++ b/libs/ardour/session_midi.cc
@@ -21,6 +21,7 @@
 #include <string>
 #include <cmath>
 #include <cerrno>
+#include <cassert>
 #include <unistd.h>
 #include <fcntl.h>
 #include <poll.h>
@@ -39,6 +40,7 @@
 #include <ardour/audio_diskstream.h>
 #include <ardour/slave.h>
 #include <ardour/cycles.h>
+#include <ardour/smpte.h>
 
 #include "i18n.h"
 
@@ -86,42 +88,81 @@ Session::use_config_midi_ports ()
 int
 Session::set_mtc_port (string port_tag)
 {
-	MTC_Slave *ms;
+#if 0
+	MIDI::byte old_device_id = 0;
+	bool reset_id = false;
 
 	if (port_tag.length() == 0) {
-
-		if (_slave && ((ms = dynamic_cast<MTC_Slave*> (_slave)) != 0)) {
-			error << _("Ardour is slaved to MTC - port cannot be reset") << endmsg;
-			return -1;
-		}
-
-		if (_mtc_port == 0) {
+		if (_mmc_port == 0) {
 			return 0;
 		}
-
-		_mtc_port = 0;
+		_mmc_port = 0;
 		goto out;
 	}
 
 	MIDI::Port* port;
 
 	if ((port = MIDI::Manager::instance()->port (port_tag)) == 0) {
-		error << string_compose (_("unknown port %1 requested for MTC"), port_tag) << endl;
 		return -1;
 	}
 
-	_mtc_port = port;
+	_mmc_port = port;
+
+	if (mmc) {
+		old_device_id = mmc->device_id();
+		reset_id = true;
+		delete mmc;
+	}
+
+	mmc = new MIDI::MachineControl (*_mmc_port, 1.0, 
+					MMC_CommandSignature,
+					MMC_ResponseSignature);
 
-	if (_slave && ((ms = dynamic_cast<MTC_Slave*> (_slave)) != 0)) {
-		ms->rebind (*port);
+	if (reset_id) {
+		mmc->set_device_id (old_device_id);
 	}
 
-	Config->set_mtc_port_name (port_tag);
+	mmc->Play.connect 
+		(mem_fun (*this, &Session::mmc_deferred_play));
+	mmc->DeferredPlay.connect 
+		(mem_fun (*this, &Session::mmc_deferred_play));
+	mmc->Stop.connect 
+		(mem_fun (*this, &Session::mmc_stop));
+	mmc->FastForward.connect 
+		(mem_fun (*this, &Session::mmc_fast_forward));
+	mmc->Rewind.connect 
+		(mem_fun (*this, &Session::mmc_rewind));
+	mmc->Pause.connect 
+		(mem_fun (*this, &Session::mmc_pause));
+	mmc->RecordPause.connect 
+		(mem_fun (*this, &Session::mmc_record_pause));
+	mmc->RecordStrobe.connect 
+		(mem_fun (*this, &Session::mmc_record_strobe));
+	mmc->RecordExit.connect 
+		(mem_fun (*this, &Session::mmc_record_exit));
+	mmc->Locate.connect 
+		(mem_fun (*this, &Session::mmc_locate));
+	mmc->Step.connect 
+		(mem_fun (*this, &Session::mmc_step));
+	mmc->Shuttle.connect 
+		(mem_fun (*this, &Session::mmc_shuttle));
+	mmc->TrackRecordStatusChange.connect
+		(mem_fun (*this, &Session::mmc_record_enable));
+
+
+	/* also handle MIDI SPP because its so common */
+
+	_mmc_port->input()->start.connect (mem_fun (*this, &Session::spp_start));
+	_mmc_port->input()->contineu.connect (mem_fun (*this, &Session::spp_continue));
+	_mmc_port->input()->stop.connect (mem_fun (*this, &Session::spp_stop));
+	
+	Config->set_mmc_port_name (port_tag);
 
   out:
-	MTC_PortChanged(); /* EMIT SIGNAL */
+	MMC_PortChanged(); /* EMIT SIGNAL */
 	change_midi_ports ();
 	set_dirty();
+#endif
 	return 0;
 }
 
@@ -136,6 +177,7 @@ Session::set_mmc_device_id (uint32_t device_id)
 int
 Session::set_mmc_port (string port_tag)
 {
+#if 0
 	MIDI::byte old_device_id = 0;
 	bool reset_id = false;
 
@@ -206,6 +248,7 @@ Session::set_mmc_port (string port_tag)
 	Config->set_mmc_port_name (port_tag);
 
   out:
+#endif
 	MMC_PortChanged(); /* EMIT SIGNAL */
 	change_midi_ports ();
 	set_dirty();
@@ -215,6 +258,7 @@ Session::set_mmc_port (string port_tag)
 int
 Session::set_midi_port (string port_tag)
 {
+#if 0
 	if (port_tag.length() == 0) {
 		if (_midi_port == 0) {
 			return 0;
@@ -238,6 +282,7 @@ Session::set_midi_port (string port_tag)
 	Config->set_midi_port_name (port_tag);
 
   out:
+#endif
 	MIDI_PortChanged(); /* EMIT SIGNAL */
 	change_midi_ports ();
 	set_dirty();
@@ -247,6 +292,7 @@ Session::set_midi_port (string port_tag)
 void
 Session::set_trace_midi_input (bool yn, MIDI::Port* port)
 {
+#if 0
 	MIDI::Parser* input_parser;
 
 	if (port) {
@@ -273,6 +319,7 @@ Session::set_trace_midi_input (bool yn, MIDI::Port* port)
 			}
 		}
 	}
+#endif
 
 	Config->set_trace_midi_input (yn);
 }
@@ -280,6 +327,7 @@ Session::set_trace_midi_input (bool yn, MIDI::Port* port)
 void
 Session::set_trace_midi_output (bool yn, MIDI::Port* port)
 {
+#if 0
 	MIDI::Parser* output_parser;
 
 	if (port) {
@@ -306,6 +354,7 @@ Session::set_trace_midi_output (bool yn, MIDI::Port* port)
 		}
 
 	}
+#endif
 
 	Config->set_trace_midi_output (yn);
 }
@@ -313,6 +362,7 @@ Session::set_trace_midi_output (bool yn, MIDI::Port* port)
 bool
 Session::get_trace_midi_input(MIDI::Port *port)
 {
+#if 0
 	MIDI::Parser* input_parser;
 	if (port) {
 		if ((input_parser = port->input()) != 0) {
@@ -338,6 +388,7 @@ Session::get_trace_midi_input(MIDI::Port *port)
 			}
 		}
 	}
+#endif
 
 	return false;
 }
@@ -345,6 +396,7 @@ Session::get_trace_midi_input(MIDI::Port *port)
 bool
 Session::get_trace_midi_output(MIDI::Port *port)
 {
+#if 0
 	MIDI::Parser* output_parser;
 	if (port) {
 		if ((output_parser = port->output()) != 0) {
@@ -370,6 +422,7 @@ Session::get_trace_midi_output(MIDI::Port *port)
 			}
 		}
 	}
+#endif
 
 	return false;
 
@@ -379,7 +432,7 @@ void
 Session::setup_midi_control ()
 {
 	outbound_mtc_smpte_frame = 0;
-	next_quarter_frame_to_send = -1;
+	next_quarter_frame_to_send = 0;
 
 	/* setup the MMC buffer */
 	
@@ -400,6 +453,7 @@ Session::setup_midi_control ()
 	mtc_msg[14] = 0xf1;
 }
 
+#if 0
 int
 Session::midi_read (MIDI::Port* port)
 {
@@ -437,6 +491,7 @@ Session::midi_read (MIDI::Port* port)
 
 	return 0;
 }
+#endif
 
 void
 Session::spp_start (Parser& ignored)
@@ -687,95 +742,52 @@ Session::mmc_record_enable (MIDI::MachineControl &mmc, size_t trk, bool enabled)
 	}
 }
 
-void
-Session::send_full_time_code_in_another_thread ()
-{
-	send_time_code_in_another_thread (true);
-}
-
-void
-Session::send_midi_time_code_in_another_thread ()
-{
-	send_time_code_in_another_thread (false);
-}
-
-void
-Session::send_time_code_in_another_thread (bool full)
-{
-	nframes_t two_smpte_frames_duration;
-	nframes_t quarter_frame_duration;
-
-	/* Duration of two smpte frames */
-	two_smpte_frames_duration = ((long) _frames_per_smpte_frame) << 1;
-
-	/* Duration of one quarter frame */
-	quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
-
-	if (_transport_frame < (outbound_mtc_smpte_frame + (next_quarter_frame_to_send * quarter_frame_duration)))
-	{
-		/* There is no work to do.
-		   We throttle this here so that we don't overload
-		   the transport thread with requests.
-		*/
-		return;
-	}
-
-	MIDIRequest* request = new MIDIRequest;
-
-	if (full) {
-		request->type = MIDIRequest::SendFullMTC;
-	} else {
-		request->type = MIDIRequest::SendMTC;
-	}
-	
-	midi_requests.write (&request, 1);
-	poke_midi_thread ();
-}
 
 void
 Session::change_midi_ports ()
 {
+/*
 	MIDIRequest* request = new MIDIRequest;
 
 	request->type = MIDIRequest::PortChange;
 	midi_requests.write (&request, 1);
 	poke_midi_thread ();
+*/
 }
 
+/** Send MTC Full Frame message (complete SMPTE time) for the start of this cycle.
+ * This resets the MTC code, the next quarter frame message that is sent will be
+ * the first one with the beginning of this cycle as the new start point.
+ *
+ * Audio thread only, realtime safe.  MIDI::Manager::cycle_start must
+ * have been called with the appropriate nframes parameter this cycle.
+ */
 int
-Session::send_full_time_code ()
-
+Session::send_full_time_code(nframes_t nframes)
 {
+	/* This function could easily send at a given frame offset, but would
+	 * that be useful?  Does ardour do sub-block accurate locating? [DR] */
+
 	MIDI::byte msg[10];
 	SMPTE::Time smpte;
 
+	_send_smpte_update = false;
+
 	if (_mtc_port == 0 || !session_send_mtc) {
 		return 0;
 	}
-
+	
 	// Get smpte time for this transport frame
 	sample_to_smpte(_transport_frame, smpte, true /* use_offset */, false /* no subframes */);
 
-	// Check for negative smpte time and prepare for quarter frame transmission
-	if (smpte.negative) {
-		// Negative mtc is not defined, so sync slave to smpte zero.
-		// When _transport_frame gets there we will start transmitting quarter frames
-		smpte.hours = 0;
-		smpte.minutes = 0;
-		smpte.seconds = 0;
-		smpte.frames = 0;
-		smpte.subframes = 0;
-		smpte.negative = false;
-		smpte_to_sample( smpte, outbound_mtc_smpte_frame, true, false );
-		transmitting_smpte_time = smpte;
-	} else {
-		transmitting_smpte_time = smpte;
-		outbound_mtc_smpte_frame = _transport_frame;
-		if (((mtc_smpte_bits >> 5) != MIDI::MTC_25_FPS) && (transmitting_smpte_time.frames % 2)) {
-			// start MTC quarter frame transmission on an even frame
-			SMPTE::increment( transmitting_smpte_time );
-			outbound_mtc_smpte_frame += (nframes_t) _frames_per_smpte_frame;
-		}
+	transmitting_smpte_time = smpte;
+	outbound_mtc_smpte_frame = _transport_frame;
+
+	// I don't understand this bit yet.. [DR]
+	if (((mtc_smpte_bits >> 5) != MIDI::MTC_25_FPS) && (transmitting_smpte_time.frames % 2)) {
+		// start MTC quarter frame transmission on an even frame
+		SMPTE::increment( transmitting_smpte_time );
+		outbound_mtc_smpte_frame += (nframes_t) _frames_per_smpte_frame;
 	}
 
 	// Compensate for audio latency
@@ -783,7 +795,7 @@ Session::send_full_time_code ()
 
 	next_quarter_frame_to_send = 0;
 
-	// Sync slave to the same smpte time as we are on (except if negative, see above)
+	// Sync slave to the same SMPTE time as we are on
 	msg[0] = 0xf0;
 	msg[1] = 0x7f;
 	msg[2] = 0x7f;
@@ -796,42 +808,60 @@ Session::send_full_time_code ()
 	msg[7] = smpte.seconds;
 	msg[8] = smpte.frames;
 
-	{
-		Glib::Mutex::Lock lm (midi_lock);
-    
-		if (_mtc_port->midimsg (msg, sizeof (msg))) {
-			error << _("Session: could not send full MIDI time code") << endmsg;
-			
-			return -1;
-		}
+	cerr << "MTC: Sending full time code at " << outbound_mtc_smpte_frame << endl;
+
+	// Send message at offset 0, sent time is for the start of this cycle
+	if (!_mtc_port->midimsg (msg, sizeof (msg), 0)) {
+		error << _("Session: could not send full MIDI time code") << endmsg;
+		return -1;
 	}
 
 	return 0;
 }
 
+
+/** Sends MTC (quarter-frame) messages for this cycle.
+ * Must be called exactly once per cycle from the audio thread.  Realtime safe.
+ * This function assumes the state of full SMPTE is sane, eg. the slave is
+ * expecting quarter frame messages and has the right frame of reference (any
+ * full MTC SMPTE time messages that needed to be sent should have been sent
+ * earlier already this cycle by send_full_time_code)
+ */
 int
-Session::send_midi_time_code ()
-{
-	if (_mtc_port == 0 || !session_send_mtc || transmitting_smpte_time.negative || (next_quarter_frame_to_send < 0) )  {
-		return 0;
+Session::send_midi_time_code_for_cycle(nframes_t nframes)
+{	
+	assert (next_quarter_frame_to_send >= 0);
+	assert (next_quarter_frame_to_send <= 7);
+	
+	if (next_quarter_frame_to_send < 0)
+	{
+		printf("Negative????\n");
 	}
 
-	nframes_t two_smpte_frames_duration;
-	nframes_t quarter_frame_duration;
-
-	/* Duration of two smpte frames */
-	two_smpte_frames_duration = ((long) _frames_per_smpte_frame) << 1;
-
+	if (_mtc_port == 0 || !session_send_mtc || transmitting_smpte_time.negative
+			/*|| (next_quarter_frame_to_send < 0)*/ ) {
+		//printf("(MTC) Not sending MTC\n");
+		return 0;
+	}
+	
 	/* Duration of one quarter frame */
-	quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
+	nframes_t quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
+	
+	//cerr << "(MTC) TR: " << _transport_frame << " - SF: " << outbound_mtc_smpte_frame
+	//<< " - NQ: " << next_quarter_frame_to_send << " - FD" << quarter_frame_duration << endl;
+		
+	// FIXME: this should always be true
+	//assert((outbound_mtc_smpte_frame + (next_quarter_frame_to_send * quarter_frame_duration))
+	//		> _transport_frame);
 
-	while (_transport_frame >= (outbound_mtc_smpte_frame + (next_quarter_frame_to_send * quarter_frame_duration))) {
+	
+	// Send quarter frames for this cycle
+	while (_transport_frame + nframes > (outbound_mtc_smpte_frame +
+				(next_quarter_frame_to_send * quarter_frame_duration))) {
 
-		// Send quarter frames up to current time
-		{
-			Glib::Mutex::Lock lm (midi_lock);
+		//cerr << "(MTC) Next frame to send: " << next_quarter_frame_to_send << endl;
 
-			switch(next_quarter_frame_to_send) {
+		switch (next_quarter_frame_to_send) {
 			case 0:
 				mtc_msg[1] =  0x00 | (transmitting_smpte_time.frames & 0xf);
 				break;
@@ -856,40 +886,56 @@ Session::send_midi_time_code ()
 			case 7:
 				mtc_msg[1] = 0x70 | (((mtc_smpte_bits|transmitting_smpte_time.hours) & 0xf0) >> 4);
 				break;
-			}			
-			
-			if (_mtc_port->midimsg (mtc_msg, 2)) {
-				error << string_compose(_("Session: cannot send quarter-frame MTC message (%1)"), strerror (errno)) 
-				      << endmsg;
-				
-				return -1;
-			}
+		}			
+		
+		const nframes_t msg_time = (outbound_mtc_smpte_frame
+			+ (quarter_frame_duration * next_quarter_frame_to_send));
+	
+		// This message must fall within this block or something is broken
+		assert(msg_time >= _transport_frame);
+		assert(msg_time < _transport_frame + nframes);
 
-			//       cout << "smpte = " << transmitting_smpte_time.hours << ":" << transmitting_smpte_time.minutes << ":" << transmitting_smpte_time.seconds << ":" << transmitting_smpte_time.frames << ", qfm = " << next_quarter_frame_to_send << endl;
-
-			// Increment quarter frame counter
-			next_quarter_frame_to_send++;
-      
-			if (next_quarter_frame_to_send >= 8) {
-				// Wrap quarter frame counter
-				next_quarter_frame_to_send = 0;
-				// Increment smpte time twice
-				SMPTE::increment( transmitting_smpte_time );
-				SMPTE::increment( transmitting_smpte_time );        
-				// Re-calculate timing of first quarter frame
-				smpte_to_sample( transmitting_smpte_time, outbound_mtc_smpte_frame, true /* use_offset */, false );
-				// Compensate for audio latency
-				outbound_mtc_smpte_frame += _worst_output_latency;
-			}
+		nframes_t out_stamp = msg_time - _transport_frame;
+		assert(out_stamp < nframes);
+
+		if (!_mtc_port->midimsg (mtc_msg, 2, out_stamp)) {
+			error << string_compose(_("Session: cannot send quarter-frame MTC message (%1)"), strerror (errno)) 
+				<< endmsg;
+			return -1;
+		}
+
+		/*cerr << "(MTC) SMPTE: " << transmitting_smpte_time.hours
+			<< ":" << transmitting_smpte_time.minutes
+			<< ":" << transmitting_smpte_time.seconds
+			<< ":" << transmitting_smpte_time.frames
+			<< ", qfm = " << next_quarter_frame_to_send
+			<< ", stamp = " << out_stamp
+			<< ", delta = " << _transport_frame + out_stamp - last_time << endl;*/
+		
+		// Increment quarter frame counter
+		next_quarter_frame_to_send++;
+
+		if (next_quarter_frame_to_send >= 8) {
+			// Wrap quarter frame counter
+			next_quarter_frame_to_send = 0;
+			// Increment smpte time twice
+			SMPTE::increment( transmitting_smpte_time );
+			SMPTE::increment( transmitting_smpte_time );        
+			// Re-calculate timing of first quarter frame
+			//smpte_to_sample( transmitting_smpte_time, outbound_mtc_smpte_frame, true /* use_offset */, false );
+			outbound_mtc_smpte_frame += 8 * quarter_frame_duration;
+			// Compensate for audio latency
+			outbound_mtc_smpte_frame += _worst_output_latency;
 		}
 	}
+
 	return 0;
 }
 
 /***********************************************************************
  OUTBOUND MMC STUFF
 **********************************************************************/
-
+/*
 void
 Session::send_mmc_in_another_thread (MIDI::MachineControl::Command cmd, nframes_t target_frame)
 {
@@ -907,7 +953,13 @@ Session::send_mmc_in_another_thread (MIDI::MachineControl::Command cmd, nframes_
 	midi_requests.write (&request, 1);
 	poke_midi_thread ();
 }
+*/
 
+/** Send an MMC command at the given absolute timestamp (@a where).
+ *
+ * This must be called in the process thread, and @a where must fall within
+ * this process cycle or horrible things will happen.
+ */
 void
 Session::deliver_mmc (MIDI::MachineControl::Command cmd, nframes_t where)
 {
@@ -916,12 +968,13 @@ Session::deliver_mmc (MIDI::MachineControl::Command cmd, nframes_t where)
 	SMPTE::Time smpte;
 
 	if (_mmc_port == 0 || !session_send_mmc) {
+		//cerr << "Not delivering MMC " << _mmc_port << " - " << send_mmc << endl;
 		return;
 	}
 
 	mmc_buffer[nbytes++] = cmd;
 
-	// cerr << "delivering MMC, cmd = " << hex << (int) cmd << dec << endl;
+	//cerr << "delivering MMC, cmd = " << hex << (int) cmd << dec << endl;
 	
 	switch (cmd) {
 	case MachineControl::cmdLocate:
@@ -941,6 +994,7 @@ Session::deliver_mmc (MIDI::MachineControl::Command cmd, nframes_t where)
 
 	case MachineControl::cmdPlay:
 		/* always convert Play into Deferred Play */
+		/* Why? [DR] */
 		mmc_buffer[4] = MachineControl::cmdDeferredPlay;
 		break;
 
@@ -964,11 +1018,14 @@ Session::deliver_mmc (MIDI::MachineControl::Command cmd, nframes_t where)
 
 		mmc_buffer[nbytes++] = 0xf7; // terminate SysEx/MMC message
 
-		Glib::Mutex::Lock lm (midi_lock);
+		assert(where >= _transport_frame);
 
-		if (_mmc_port->write (mmc_buffer, nbytes) != nbytes) {
+		// FIXME: timestamp correct? [DR]
+		if (!_mmc_port->midimsg (mmc_buffer, sizeof (mmc_buffer), where - _transport_frame)) {
 			error << string_compose(_("MMC: cannot send command %1%2%3"), &hex, cmd, &dec) << endmsg;
-		}
+		} /*else {
+			cerr << "Sending MMC\n";
+		}*/
 	}
 }
 
@@ -1006,7 +1063,7 @@ void
 Session::send_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t ch, MIDI::EventTwoBytes data)
 {
 	// in another thread, really
-	
+	/*
 	MIDIRequest* request = new MIDIRequest;
 
 	request->type = MIDIRequest::SendMessage;
@@ -1017,13 +1074,14 @@ Session::send_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel
 	
 	midi_requests.write (&request, 1);
 	poke_midi_thread ();
+	*/
 }
 
 void
 Session::deliver_midi (MIDI::Port * port, MIDI::byte* buf, int32_t bufsize)
 {
 	// in another thread, really
-	
+	/*
 	MIDIRequest* request = new MIDIRequest;
 
 	request->type = MIDIRequest::Deliver;
@@ -1033,8 +1091,14 @@ Session::deliver_midi (MIDI::Port * port, MIDI::byte* buf, int32_t bufsize)
 	
 	midi_requests.write (&request, 1);
 	poke_midi_thread ();
+	*/
 }
 
+#if 0
+
+This is aaalll gone. 
+
+
 void
 Session::deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t ch, MIDI::EventTwoBytes data)
 {
@@ -1060,11 +1124,14 @@ Session::deliver_data (MIDI::Port * port, MIDI::byte* buf, int32_t size)
 
 	delete [] buf;
 }
+#endif
+
 
 /*---------------------------------------------------------------------------
   MIDI THREAD 
   ---------------------------------------------------------------------------*/
 
+#if 0
 int
 Session::start_midi_thread ()
 {
@@ -1347,4 +1414,5 @@ Session::midi_thread_work ()
 		}
 	}
 }
+#endif
 
diff --git a/libs/ardour/session_process.cc b/libs/ardour/session_process.cc
index 055cbcf82d..4f82de1c0e 100644
--- a/libs/ardour/session_process.cc
+++ b/libs/ardour/session_process.cc
@@ -23,7 +23,7 @@
 #include <unistd.h>
 
 #include <pbd/error.h>
- 
+
 #include <glibmm/thread.h>
 
 #include <ardour/ardour.h>
@@ -36,6 +36,8 @@
 #include <ardour/cycles.h>
 #include <ardour/cycle_timer.h>
 
+#include <midi++/manager.h>
+
 #include "i18n.h"
 
 using namespace ARDOUR;
@@ -45,6 +47,8 @@ using namespace std;
 void
 Session::process (nframes_t nframes)
 {
+	MIDI::Manager::instance()->cycle_start(nframes);
+
 	if (synced_to_jack() && waiting_to_start) {
 		if ( _engine.transport_state() == AudioEngine::TransportRolling) {
 			actually_start_transport ();
@@ -58,6 +62,8 @@ Session::process (nframes_t nframes)
 	} 
 	
 	(this->*process_function) (nframes);
+	
+	MIDI::Manager::instance()->cycle_end();
 
 	SendFeedback (); /* EMIT SIGNAL */
 }
@@ -74,7 +80,7 @@ Session::prepare_diskstreams ()
 int
 Session::no_roll (nframes_t nframes, nframes_t offset)
 {
-	nframes_t end_frame = _transport_frame + nframes;
+	nframes_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
 	int ret = 0;
 	bool declick = get_transport_declick_required();
 	boost::shared_ptr<RouteList> r = routes.reader ();
@@ -124,6 +130,9 @@ Session::process_routes (nframes_t nframes, nframes_t offset)
 
 	record_active = actively_recording(); // || (get_record_enabled() && get_punch_in());
 
+	const nframes_t start_frame = _transport_frame;
+	const nframes_t end_frame = _transport_frame + (nframes_t)floor(nframes * _transport_speed);
+
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
 		int ret;
@@ -134,7 +143,7 @@ Session::process_routes (nframes_t nframes, nframes_t offset)
 
 		(*i)->set_pending_declick (declick);
 
-		if ((ret = (*i)->roll (nframes, _transport_frame, _transport_frame + nframes, offset, declick, record_active, rec_monitors)) < 0) {
+		if ((ret = (*i)->roll (nframes, start_frame, end_frame, offset, declick, record_active, rec_monitors)) < 0) {
 
 			/* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(),
 			   and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that
@@ -166,6 +175,9 @@ Session::silent_process_routes (nframes_t nframes, nframes_t offset)
 		/* force a declick out */
 		declick = -1;
 	}
+	
+	const nframes_t start_frame = _transport_frame;
+	const nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
 
 	for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
 
@@ -175,7 +187,7 @@ Session::silent_process_routes (nframes_t nframes, nframes_t offset)
 			continue;
 		}
 
-		if ((ret = (*i)->silent_roll (nframes, _transport_frame, _transport_frame + nframes, offset, record_active, rec_monitors)) < 0) {
+		if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, offset, record_active, rec_monitors)) < 0) {
 			
 			/* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(),
 			   and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that
@@ -243,16 +255,17 @@ Session::commit_diskstreams (nframes_t nframes, bool &needs_butler)
 	}
 }
 
+
 void
 Session::process_with_events (nframes_t nframes)
 {
-	Event* ev;
+	Event*         ev;
 	nframes_t this_nframes;
 	nframes_t end_frame;
 	nframes_t offset;
-	bool session_needs_butler = false;
 	nframes_t stop_limit;
 	long           frames_moved;
+	bool           session_needs_butler = false;
 
 	/* make sure the auditioner is silent */
 
@@ -277,11 +290,19 @@ Session::process_with_events (nframes_t nframes)
 		process_event (ev);
 	}
 
+	/* Events caused a transport change, send an MTC Full Frame (SMPTE) message.
+	 * This is sent whether rolling or not, to give slaves an idea of ardour time
+	 * on locates (and allow slow slaves to position and prepare for rolling)
+	 */
+	if (_send_smpte_update) {
+		send_full_time_code(nframes);
+	}
+
 	if (!process_can_proceed()) {
 		no_roll (nframes, 0);
 		return;
 	}
-		
+
 	if (events.empty() || next_event == events.end()) {
 		process_without_events (nframes);
 		return;
@@ -308,6 +329,8 @@ Session::process_with_events (nframes_t nframes)
 			no_roll (nframes, 0);
 			return;
 		}
+	
+		send_midi_time_code_for_cycle(nframes);
 
 		if (actively_recording()) {
 			stop_limit = max_frames;
@@ -399,17 +422,9 @@ Session::process_with_events (nframes_t nframes)
 
 	} /* implicit release of route lock */
 
-
-	if (session_needs_butler) {
+	if (session_needs_butler)
 		summon_butler ();
-	} 
-	
-	if (!_engine.freewheeling() && session_send_mtc) {
-		send_midi_time_code_in_another_thread ();
-	}
-
-	return;
-}		
+}
 
 void
 Session::reset_slave_state ()
@@ -556,7 +571,6 @@ Session::follow_slave (nframes_t nframes, nframes_t offset)
 		if (slave_state == Waiting) {
 
 			// cerr << "waiting at " << slave_transport_frame << endl;
-			
 			if (slave_transport_frame >= slave_wait_end) {
 				// cerr << "\tstart at " << _transport_frame << endl;
 
@@ -740,6 +754,8 @@ Session::process_without_events (nframes_t nframes)
 			no_roll (nframes, 0);
 			return;
 		}
+	
+		send_midi_time_code_for_cycle(nframes);
 		
 		if (actively_recording()) {
 			stop_limit = max_frames;
@@ -784,16 +800,9 @@ Session::process_without_events (nframes_t nframes)
 
 	} /* implicit release of route lock */
 
-	if (session_needs_butler) {
+	if (session_needs_butler)
 		summon_butler ();
-	} 
-	
-	if (!_engine.freewheeling() && session_send_mtc) {
-		send_midi_time_code_in_another_thread ();
-	}
-
-	return;
-}		
+}
 
 void
 Session::process_audition (nframes_t nframes)
diff --git a/libs/ardour/session_state.cc b/libs/ardour/session_state.cc
index b499866395..d670173bd5 100644
--- a/libs/ardour/session_state.cc
+++ b/libs/ardour/session_state.cc
@@ -17,6 +17,9 @@
     
 */
 
+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+
 #include <algorithm>
 #include <fstream>
 #include <string>
@@ -59,12 +62,17 @@
 #include <ardour/audioengine.h>
 #include <ardour/configuration.h>
 #include <ardour/session.h>
+#include <ardour/buffer.h>
 #include <ardour/audio_diskstream.h>
+#include <ardour/midi_diskstream.h>
 #include <ardour/utils.h>
 #include <ardour/audioplaylist.h>
+#include <ardour/midi_playlist.h>
+#include <ardour/smf_source.h>
 #include <ardour/audiofilesource.h>
 #include <ardour/silentfilesource.h>
 #include <ardour/sndfilesource.h>
+#include <ardour/midi_source.h>
 #include <ardour/sndfile_helpers.h>
 #include <ardour/auditioner.h>
 #include <ardour/export.h>
@@ -75,12 +83,14 @@
 #include <ardour/slave.h>
 #include <ardour/tempo.h>
 #include <ardour/audio_track.h>
+#include <ardour/midi_track.h>
 #include <ardour/cycle_timer.h>
 #include <ardour/utils.h>
 #include <ardour/named_selection.h>
 #include <ardour/version.h>
 #include <ardour/location.h>
 #include <ardour/audioregion.h>
+#include <ardour/midi_region.h>
 #include <ardour/crossfade.h>
 #include <ardour/control_protocol_manager.h>
 #include <ardour/region_factory.h>
@@ -185,10 +195,10 @@ Session::first_stage_init (string fullpath, string snapshot_name)
 	first_file_data_format_reset = true;
 	first_file_header_format_reset = true;
 	butler_thread = (pthread_t) 0;
-	midi_thread = (pthread_t) 0;
+	//midi_thread = (pthread_t) 0;
 
 	AudioDiskstream::allocate_working_buffers();
-	
+
 	/* default short fade = 15ms */
 
 	Crossfade::set_short_xfade_length ((nframes_t) floor (Config->get_short_xfade_seconds() * frame_rate()));
@@ -247,11 +257,11 @@ Session::first_stage_init (string fullpath, string snapshot_name)
 	PlaylistFactory::PlaylistCreated.connect (mem_fun (*this, &Session::add_playlist));
 	Redirect::RedirectCreated.connect (mem_fun (*this, &Session::add_redirect));
 	NamedSelection::NamedSelectionCreated.connect (mem_fun (*this, &Session::add_named_selection));
-        AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list));
+	AutomationList::AutomationListCreated.connect (mem_fun (*this, &Session::add_automation_list));
 
 	Controllable::Destroyed.connect (mem_fun (*this, &Session::remove_controllable));
 
-	IO::MoreOutputs.connect (mem_fun (*this, &Session::ensure_passthru_buffers));
+	IO::MoreChannels.connect (mem_fun (*this, &Session::ensure_buffers));
 
 	/* stop IO objects from doing stuff until we're ready for them */
 
@@ -276,9 +286,9 @@ Session::second_stage_init (bool new_session)
 		return -1;
 	}
 
-	if (start_midi_thread ()) {
+	/*if (start_midi_thread ()) {
 		return -1;
-	}
+	}*/
 
 	// set_state() will call setup_raid_path(), but if it's a new session we need
 	// to call setup_raid_path() here.
@@ -329,7 +339,7 @@ Session::second_stage_init (bool new_session)
 		return -1;
 	}
 
-	send_full_time_code ();
+	//send_full_time_code ();
 	_engine.transport_locate (0);
 	deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
 	deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
@@ -402,6 +412,7 @@ Session::setup_raid_path (string path)
 		fspath += sound_dir (false);
 		
 		AudioFileSource::set_search_path (fspath);
+		SMFSource::set_search_path (fspath); // FIXME: should be different
 
 		return;
 	}
@@ -445,6 +456,7 @@ Session::setup_raid_path (string path)
 	/* set the AudioFileSource search path */
 
 	AudioFileSource::set_search_path (fspath);
+	SMFSource::set_search_path (fspath); // FIXME: should be different
 
 	/* reset the round-robin soundfile path thingie */
 
@@ -558,15 +570,22 @@ Session::load_diskstreams (const XMLNode& node)
 	clist = node.children();
 
 	for (citer = clist.begin(); citer != clist.end(); ++citer) {
-		
 
 		try {
-			boost::shared_ptr<AudioDiskstream> dstream (new AudioDiskstream (*this, **citer));
-			add_diskstream (dstream);
+			/* diskstreams added automatically by DiskstreamCreated handler */
+			if ((*citer)->name() == "AudioDiskstream" || (*citer)->name() == "DiskStream") {
+				boost::shared_ptr<AudioDiskstream> dstream (new AudioDiskstream (*this, **citer));
+				add_diskstream (dstream);
+			} else if ((*citer)->name() == "MidiDiskstream") {
+				boost::shared_ptr<MidiDiskstream> dstream (new MidiDiskstream (*this, **citer));
+				add_diskstream (dstream);
+			} else {
+				error << _("Session: unknown diskstream type in XML") << endmsg;
+			}
 		} 
 		
 		catch (failed_constructor& err) {
-			error << _("Session: could not load diskstream via XML state")			      << endmsg;
+			error << _("Session: could not load diskstream via XML state") << endmsg;
 			return -1;
 		}
 	}
@@ -947,9 +966,9 @@ Session::state(bool full_state)
 	child = node->add_child ("Sources");
 
 	if (full_state) {
-		Glib::Mutex::Lock sl (audio_source_lock);
+		Glib::Mutex::Lock sl (source_lock);
 
-		for (AudioSourceList::iterator siter = audio_sources.begin(); siter != audio_sources.end(); ++siter) {
+		for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
 			
 			/* Don't save information about AudioFileSources that are empty */
 			
@@ -957,8 +976,8 @@ Session::state(bool full_state)
 
 			if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
 
-				/* destructive file sources are OK if they are empty, because
-				   we will re-use them every time.
+				/* Don't save sources that are empty, unless they're destructive (which are OK
+				   if they are empty, because we will re-use them every time.)
 				*/
 
 				if (!fs->destructive()) {
@@ -977,7 +996,7 @@ Session::state(bool full_state)
 	if (full_state) { 
 		Glib::Mutex::Lock rl (region_lock);
 
-		for (AudioRegionList::const_iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
+		for (RegionList::const_iterator i = regions.begin(); i != regions.end(); ++i) {
 			
 			/* only store regions not attached to playlists */
 
@@ -1355,12 +1374,26 @@ Session::XMLRouteFactory (const XMLNode& node)
 		return boost::shared_ptr<Route> ((Route*) 0);
 	}
 
-	if (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0) {
-		boost::shared_ptr<Route> x (new AudioTrack (*this, node));
-		return x;
+	bool has_diskstream = (node.property ("diskstream") != 0 || node.property ("diskstream-id") != 0);
+	
+	DataType type = DataType::AUDIO;
+	const XMLProperty* prop = node.property("default-type");
+	if (prop)
+		type = DataType(prop->value());
+	
+	assert(type != DataType::NIL);
+
+	if (has_diskstream) {
+		if (type == DataType::AUDIO) {
+			boost::shared_ptr<Route> ret (new AudioTrack (*this, node));
+			return ret;
+		} else {
+			boost::shared_ptr<Route> ret (new MidiTrack (*this, node));
+			return ret;
+		}
 	} else {
-		boost::shared_ptr<Route> x (new Route (*this, node));
-		return x;
+		boost::shared_ptr<Route> ret (new Route (*this, node));
+		return ret;
 	}
 }
 
@@ -1369,7 +1402,7 @@ Session::load_regions (const XMLNode& node)
 {
 	XMLNodeList nlist;
 	XMLNodeConstIterator niter;
-	boost::shared_ptr<AudioRegion> region;
+	boost::shared_ptr<Region> region;
 
 	nlist = node.children();
 
@@ -1384,9 +1417,33 @@ Session::load_regions (const XMLNode& node)
 	return 0;
 }
 
-boost::shared_ptr<AudioRegion>
+boost::shared_ptr<Region>
 Session::XMLRegionFactory (const XMLNode& node, bool full)
 {
+	const XMLProperty* type = node.property("type");
+
+	try {
+	
+	if ( !type || type->value() == "audio" ) {
+
+		return boost::shared_ptr<Region>(XMLAudioRegionFactory (node, full));
+	
+	} else if (type->value() == "midi") {
+		
+		return boost::shared_ptr<Region>(XMLMidiRegionFactory (node, full));
+
+	}
+	
+	} catch (failed_constructor& err) {
+		return boost::shared_ptr<Region> ();
+	}
+
+	return boost::shared_ptr<Region> ();
+}
+
+boost::shared_ptr<AudioRegion>
+Session::XMLAudioRegionFactory (const XMLNode& node, bool full)
+{
 	const XMLProperty* prop;
 	boost::shared_ptr<Source> source;
 	boost::shared_ptr<AudioSource> as;
@@ -1476,14 +1533,66 @@ Session::XMLRegionFactory (const XMLNode& node, bool full)
 	}
 }
 
+boost::shared_ptr<MidiRegion>
+Session::XMLMidiRegionFactory (const XMLNode& node, bool full)
+{
+	const XMLProperty* prop;
+	boost::shared_ptr<Source> source;
+	boost::shared_ptr<MidiSource> ms;
+	MidiRegion::SourceList sources;
+	uint32_t nchans = 1;
+	
+	if (node.name() != X_("Region")) {
+		return boost::shared_ptr<MidiRegion>();
+	}
+
+	if ((prop = node.property (X_("channels"))) != 0) {
+		nchans = atoi (prop->value().c_str());
+	}
+
+	// Multiple midi channels?  that's just crazy talk
+	assert(nchans == 1);
+
+	if ((prop = node.property (X_("source-0"))) == 0) {
+		if ((prop = node.property ("source")) == 0) {
+			error << _("Session: XMLNode describing a MidiRegion is incomplete (no source)") << endmsg;
+			return boost::shared_ptr<MidiRegion>();
+		}
+	}
+
+	PBD::ID s_id (prop->value());
+
+	if ((source = source_by_id (s_id)) == 0) {
+		error << string_compose(_("Session: XMLNode describing a MidiRegion references an unknown source id =%1"), s_id) << endmsg;
+		return boost::shared_ptr<MidiRegion>();
+	}
+
+	ms = boost::dynamic_pointer_cast<MidiSource>(source);
+	if (!ms) {
+		error << string_compose(_("Session: XMLNode describing a MidiRegion references a non-midi source id =%1"), s_id) << endmsg;
+		return boost::shared_ptr<MidiRegion>();
+	}
+
+	sources.push_back (ms);
+
+	try {
+		boost::shared_ptr<MidiRegion> region (boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (sources, node)));
+		return region;
+	}
+
+	catch (failed_constructor& err) {
+		return boost::shared_ptr<MidiRegion>();
+	}
+}
+
 XMLNode&
 Session::get_sources_as_xml ()
 
 {
 	XMLNode* node = new XMLNode (X_("Sources"));
-	Glib::Mutex::Lock lm (audio_source_lock);
+	Glib::Mutex::Lock lm (source_lock);
 
-	for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
+	for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
 		node->add_child_nocopy (i->second->get_state());
 	}
 
@@ -1856,7 +1965,6 @@ Session::load_unused_playlists (const XMLNode& node)
 	return 0;
 }
 
-
 boost::shared_ptr<Playlist>
 Session::XMLPlaylistFactory (const XMLNode& node)
 {
@@ -2628,9 +2736,9 @@ Session::cleanup_sources (Session::cleanup_report& rep)
 	rep.paths.clear ();
 	rep.space = 0;
 
-	for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ) {
+	for (SourceMap::iterator i = sources.begin(); i != sources.end(); ) {
 		
-		AudioSourceList::iterator tmp;
+		SourceMap::iterator tmp;
 
 		tmp = i;
 		++tmp;
@@ -2684,7 +2792,7 @@ Session::cleanup_sources (Session::cleanup_report& rep)
 	/*  add our current source list
 	 */
 	
-	for (AudioSourceList::iterator i = audio_sources.begin(); i != audio_sources.end(); ++i) {
+	for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
 		boost::shared_ptr<AudioFileSource> fs;
 		
 		if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (i->second)) != 0) {
@@ -3165,7 +3273,7 @@ Session::config_changed (const char* parameter_name)
 
 	} else if (PARAM_IS ("mmc-control")) {
 
-		poke_midi_thread ();
+		//poke_midi_thread ();
 
 	} else if (PARAM_IS ("mmc-device-id")) {
 
@@ -3175,7 +3283,7 @@ Session::config_changed (const char* parameter_name)
 
 	} else if (PARAM_IS ("midi-control")) {
 		
-		poke_midi_thread ();
+		//poke_midi_thread ();
 
 	} else if (PARAM_IS ("raid-path")) {
 
diff --git a/libs/ardour/session_time.cc b/libs/ardour/session_time.cc
index 486b94f27b..a388e31d80 100644
--- a/libs/ardour/session_time.cc
+++ b/libs/ardour/session_time.cc
@@ -567,7 +567,7 @@ Session::jack_timebase_callback (jack_transport_state_t state,
 #endif		
 }
 
-nframes_t
+ARDOUR::nframes_t
 Session::convert_to_frames_at (nframes_t position, AnyTime& any)
 {
 	double secs;
diff --git a/libs/ardour/session_timefx.cc b/libs/ardour/session_timefx.cc
index 37b0aa1d48..4061b2ccd0 100644
--- a/libs/ardour/session_timefx.cc
+++ b/libs/ardour/session_timefx.cc
@@ -94,7 +94,7 @@ Session::tempoize_region (TimeStretchRequest& tsr)
 		}
 
 		try {
-			sources.push_back (boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (*this, path, false, frame_rate())));
+			sources.push_back (boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (DataType::AUDIO, *this, path, false, frame_rate())));
 
 		} catch (failed_constructor& err) {
 			error << string_compose (_("tempoize: error creating new audio file %1 (%2)"), path, strerror (errno)) << endmsg;
@@ -112,6 +112,12 @@ Session::tempoize_region (TimeStretchRequest& tsr)
 			nframes_t pos = 0;
 			nframes_t this_read = 0;
 
+			boost::shared_ptr<AudioSource> asrc = boost::dynamic_pointer_cast<AudioSource>(sources[i]);
+			if (!asrc) {
+				cerr << "FIXME: TimeFX for non-audio" << endl;
+				continue;
+			}
+
 			st.clear();
 			while (tsr.running && pos < tsr.region->length()) {
 				nframes_t this_time;
@@ -135,7 +141,7 @@ Session::tempoize_region (TimeStretchRequest& tsr)
 				st.putSamples (buffer, this_read);
 			
 				while ((this_read = st.receiveSamples (buffer, bufsize)) > 0 && tsr.running) {
-					if (sources[i]->write (buffer, this_read) != this_read) {
+					if (asrc->write (buffer, this_read) != this_read) {
 						error << string_compose (_("error writing tempo-adjusted data to %1"), sources[i]->name()) << endmsg;
 						goto out;
 					}
@@ -147,7 +153,7 @@ Session::tempoize_region (TimeStretchRequest& tsr)
 			}
 		
 			while (tsr.running && (this_read = st.receiveSamples (buffer, bufsize)) > 0) {
-				if (sources[i]->write (buffer, this_read) != this_read) {
+				if (asrc->write (buffer, this_read) != this_read) {
 					error << string_compose (_("error writing tempo-adjusted data to %1"), sources[i]->name()) << endmsg;
 					goto out;
 				}
diff --git a/libs/ardour/session_transport.cc b/libs/ardour/session_transport.cc
index 22d30fda9d..b199d77f97 100644
--- a/libs/ardour/session_transport.cc
+++ b/libs/ardour/session_transport.cc
@@ -134,6 +134,11 @@ void
 Session::realtime_stop (bool abort)
 {
 	/* assume that when we start, we'll be moving forwards */
+	
+	// FIXME: where should this really be? [DR]
+	//send_full_time_code();
+	deliver_mmc (MIDI::MachineControl::cmdStop, _transport_frame);
+	deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
 
 	if (_transport_speed < 0.0f) {
 		post_transport_work = PostTransportWork (post_transport_work | PostTransportStop | PostTransportReverse);
@@ -405,16 +410,13 @@ Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
 				return;
 			}
 		}
+
 #ifdef LEAVE_TRANSPORT_UNADJUSTED
 	}
 #endif
 
 	last_stop_frame = _transport_frame;
 
-	send_full_time_code ();
-	deliver_mmc (MIDI::MachineControl::cmdStop, 0);
-	deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
-
 	if (did_record) {
 
 		/* XXX its a little odd that we're doing this here
@@ -625,7 +627,12 @@ Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool w
 		return;
 	}
 
+	// Update SMPTE time
+	// [DR] FIXME: find out exactly where this should go below
 	_transport_frame = target_frame;
+	smpte_time(_transport_frame, transmitting_smpte_time);
+	outbound_mtc_smpte_frame = _transport_frame;
+	next_quarter_frame_to_send = 0;
 
 	if (_transport_speed && (!with_loop || loop_changing)) {
 		/* schedule a declick. we'll be called again when its done */
@@ -707,6 +714,8 @@ Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool w
 	}
 	
 	loop_changing = false;
+
+	_send_smpte_update = true;
 }
 
 void
@@ -901,11 +910,14 @@ Session::actually_start_transport ()
 		(*i)->realtime_set_speed ((*i)->speed(), true);
 	}
 
-	send_mmc_in_another_thread (MIDI::MachineControl::cmdDeferredPlay, 0);
-	
+	deliver_mmc(MIDI::MachineControl::cmdDeferredPlay, _transport_frame);
+
 	TransportStateChange (); /* EMIT SIGNAL */
 }
 
+/** Do any transport work in the audio thread that needs to be done after the
+ * transport thread is finished.  Audio thread, realtime safe.
+ */
 void
 Session::post_transport ()
 {
diff --git a/libs/ardour/smf_source.cc b/libs/ardour/smf_source.cc
new file mode 100644
index 0000000000..d41b47bd68
--- /dev/null
+++ b/libs/ardour/smf_source.cc
@@ -0,0 +1,746 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+	Written by Dave Robillard, 2006
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program 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 General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <vector>
+
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <pbd/mountpoint.h>
+#include <pbd/pathscanner.h>
+#include <pbd/stl_delete.h>
+#include <pbd/strsplit.h>
+
+#include <glibmm/miscutils.h>
+
+#include <ardour/smf_source.h>
+#include <ardour/session.h>
+#include <ardour/midi_ring_buffer.h>
+#include <ardour/midi_util.h>
+
+#include "i18n.h"
+
+using namespace ARDOUR;
+
+string SMFSource::_search_path;
+
+/*sigc::signal<void,struct tm*, time_t> SMFSource::HeaderPositionOffsetChanged;
+bool                                  SMFSource::header_position_negative;
+uint64_t                              SMFSource::header_position_offset;
+*/
+
+SMFSource::SMFSource (Session& s, std::string path, Flag flags)
+	: MidiSource (s, region_name_from_path(path, false))
+	, _channel(0)
+	, _flags (Flag(flags | Writable)) // FIXME: this needs to be writable for now
+	, _allow_remove_if_empty(true)
+	, _timeline_position (0)
+	, _fd (0)
+	, _last_ev_time(0)
+	, _track_size(4) // 4 bytes for the ever-present EOT event
+	, _header_size(22)
+{
+	/* constructor used for new internal-to-session files. file cannot exist */
+
+	if (init (path, false)) {
+		throw failed_constructor ();
+	}
+	
+	if (open()) {
+		throw failed_constructor ();
+	}
+	
+	assert(_name.find("/") == string::npos);
+}
+
+SMFSource::SMFSource (Session& s, const XMLNode& node)
+	: MidiSource (s, node)
+	, _channel(0)
+	, _flags (Flag (Writable|CanRename))
+	, _allow_remove_if_empty(true)
+	, _timeline_position (0)
+	, _fd (0)
+	, _last_ev_time(0)
+	, _track_size(4) // 4 bytes for the ever-present EOT event
+	, _header_size(22)
+{
+	/* constructor used for existing internal-to-session files. file must exist */
+
+	if (set_state (node)) {
+		throw failed_constructor ();
+	}
+	
+	if (init (_name, true)) {
+		throw failed_constructor ();
+	}
+	
+	if (open()) {
+		throw failed_constructor ();
+	}
+	
+	assert(_name.find("/") == string::npos);
+}
+
+SMFSource::~SMFSource ()
+{
+	if (removable()) {
+		unlink (_path.c_str());
+	}
+}
+
+bool
+SMFSource::removable () const
+{
+	return (_flags & Removable) && ((_flags & RemoveAtDestroy) || 
+				      ((_flags & RemovableIfEmpty) && is_empty (_path)));
+}
+
+int
+SMFSource::init (string pathstr, bool must_exist)
+{
+	bool is_new = false;
+
+	if (!find (pathstr, must_exist, is_new)) {
+		cerr << "cannot find " << pathstr << " with me = " << must_exist << endl;
+		return -1;
+	}
+
+	if (is_new && must_exist) {
+		return -1;
+	}
+
+	assert(_name.find("/") == string::npos);
+	return 0;
+}
+
+int
+SMFSource::open()
+{
+	cerr << "Opening SMF file " << path() << " writeable: " << writable() << endl;
+
+	assert(writable()); // FIXME;
+
+	_fd = fopen(path().c_str(), "r+");
+
+	// File already exists
+	if (_fd) {
+		fseek(_fd, _header_size - 4, 0);
+		uint32_t track_size_be = 0;
+		fread(&track_size_be, 4, 1, _fd);
+		_track_size = GUINT32_FROM_BE(track_size_be);
+		cerr << "SMF - read track size " << _track_size;
+
+	// We're making a new file
+	} else {
+		_fd = fopen(path().c_str(), "w+");
+		_track_size = 0;
+
+		// write a tentative header just to pad things out so writing happens in the right spot
+		flush_header();
+		// FIXME: write the footer here too so it's a valid SMF (screw up writing ATM though)
+	}
+
+	return (_fd == 0) ? -1 : 0;
+}
+
+int
+SMFSource::update_header (nframes_t when, struct tm&, time_t)
+{
+	_timeline_position = when;
+	return flush_header();
+}
+
+int
+SMFSource::flush_header ()
+{
+	// FIXME: write timeline position somehow?
+	
+	cerr << "SMF Flushing header\n";
+
+	assert(_fd);
+
+	const uint16_t type     = GUINT16_TO_BE(0);    // SMF Type 0 (single track)
+	const uint16_t ntracks  = GUINT16_TO_BE(1);    // Number of tracks (always 1 for Type 0)
+	const uint16_t division = GUINT16_TO_BE(1920); // FIXME FIXME FIXME PPQN
+
+	char data[6];
+	memcpy(data, &type, 2);
+	memcpy(data+2, &ntracks, 2);
+	memcpy(data+4, &division, 2);
+
+	_fd = freopen(path().c_str(), "r+", _fd);
+	assert(_fd);
+	fseek(_fd, 0, 0);
+	write_chunk("MThd", 6, data);
+	//if (_track_size > 0) {
+		write_chunk_header("MTrk", _track_size); 
+	//}
+
+	fflush(_fd);
+
+	return 0;
+}
+
+int
+SMFSource::flush_footer()
+{
+	cerr << "SMF - Writing EOT\n";
+
+	fseek(_fd, 0, SEEK_END);
+	write_var_len(1); // whatever...
+	char eot[4] = { 0xFF, 0x2F, 0x00 }; // end-of-track meta-event
+	fwrite(eot, 1, 4, _fd);
+	fflush(_fd);
+	return 0;
+}
+
+/** Returns the offset of the first event in the file with a time past @a start,
+ * relative to the start of the source.
+ *
+ * Returns -1 if not found.
+ */
+/*
+long
+SMFSource::find_first_event_after(nframes_t start)
+{
+	// FIXME: obviously this is slooow
+	
+	fseek(_fd, _header_size, 0);
+
+	while ( ! feof(_fd) ) {
+		const uint32_t delta_time = read_var_len();
+
+		if (delta_time > start)
+			return delta_time;
+	}
+
+	return -1;
+}
+*/
+
+/** Read an event from the current position in file.
+ *
+ * File position MUST be at the beginning of a delta time, or this will die very messily.
+ * ev.buffer must be of size ev.size, and large enough for the event.  The returned event
+ * will have it's time field set to it's delta time (so it's the caller's responsibility
+ * to calculate a real time for the event).
+ *
+ * Returns event length (including status byte) on success, 0 if event was
+ * skipped (eg a meta event), or -1 on EOF (or end of track).
+ */
+int
+SMFSource::read_event(MidiEvent& ev) const
+{
+	// - 4 is for the EOT event, which we don't actually want to read
+	//if (feof(_fd) || ftell(_fd) >= _header_size + _track_size - 4) {
+	if (feof(_fd)) {
+		return -1;
+	}
+
+	uint32_t delta_time = read_var_len();
+	int status = fgetc(_fd);
+	assert(status != EOF); // FIXME die gracefully
+	if (status == 0xFF) {
+		assert(!feof(_fd));
+		int type = fgetc(_fd);
+		if ((unsigned char)type == 0x2F) {
+			//cerr << "SMF - hit EOT" << endl;
+			return -1; // we hit the logical EOF anyway...
+		} else {
+			ev.size = 0;
+			ev.time = delta_time; // this is needed regardless
+			return 0;
+		}
+	}
+
+	ev.buffer[0] = (unsigned char)status;
+	ev.size = midi_event_size(ev.buffer[0]) + 1;
+	fread(ev.buffer+1, 1, ev.size - 1, _fd);
+	ev.time = delta_time;
+
+	/*printf("SMF - read event, delta = %u, size = %zu, data = ",
+		delta_time, ev.size);
+	for (size_t i=0; i < ev.size; ++i) {
+		printf("%X ", ev.buffer[i]);
+	}
+	printf("\n");*/
+	
+	return ev.size;
+}
+
+nframes_t
+SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const
+{
+	//cerr << "SMF - read " << start << ", count=" << cnt << ", offset=" << stamp_offset << endl;
+
+	nframes_t time = 0;
+
+	// FIXME: ugh
+	unsigned char ev_buf[MidiBuffer::max_event_size()];
+	MidiEvent ev;
+	ev.time = 0;
+	ev.size = MidiBuffer::max_event_size();
+	ev.buffer = ev_buf;
+
+	// FIXME: it would be an impressive feat to actually make this any slower :)
+	
+	fseek(_fd, _header_size, 0);
+	
+	while (!feof(_fd)) {
+		int ret = read_event(ev);
+		if (ret == -1) { // EOF
+			//cerr << "SMF - EOF\n";
+			break;
+		}
+
+		if (ret == 0) { // meta-event (skipped)
+			//cerr << "SMF - META\n";
+			time += ev.time; // just accumulate delta time and ignore event
+			continue;
+		}
+
+		time += ev.time; // accumulate delta time
+		ev.time = time; // set ev.time to actual time (relative to source start)
+
+		if (ev.time >= start) {
+			if (ev.time > start + cnt) {
+				break;
+			} else {
+				ev.time += stamp_offset;
+				dst.write(ev);
+			}
+		}
+	}
+	
+	return cnt;
+}
+
+nframes_t
+SMFSource::write_unlocked (MidiRingBuffer& src, nframes_t cnt)
+{
+	//cerr << "SMF WRITE -- " << _length << "--" << cnt << endl;
+	
+	MidiBuffer buf(1024); // FIXME: allocation, size?
+	src.read(buf, /*_length*/0, _length + cnt); // FIXME?
+
+	fseek(_fd, 0, SEEK_END);
+
+	// FIXME: start of source time?
+	
+	for (size_t i=0; i < buf.size(); ++i) {
+		const MidiEvent& ev = buf[i];
+		assert(ev.time >= _timeline_position);
+		uint32_t delta_time = (ev.time - _timeline_position) - _last_ev_time;
+		
+		/*printf("SMF - writing event, delta = %u, size = %zu, data = ",
+			delta_time, ev.size);
+		for (size_t i=0; i < ev.size; ++i) {
+			printf("%X ", ev.buffer[i]);
+		}
+		printf("\n");
+		*/
+		size_t stamp_size = write_var_len(delta_time);
+		fwrite(ev.buffer, 1, ev.size, _fd);
+		_last_ev_time += delta_time;
+		_track_size += stamp_size + ev.size;
+	}
+
+	fflush(_fd);
+
+	if (buf.size() > 0) {
+		ViewDataRangeReady (_length, cnt); /* EMIT SIGNAL */
+	}
+
+	update_length(_length, cnt);
+	return cnt;
+}
+
+XMLNode&
+SMFSource::get_state ()
+{
+	XMLNode& root (MidiSource::get_state());
+	char buf[16];
+	snprintf (buf, sizeof (buf), "0x%x", (int)_flags);
+	root.add_property ("flags", buf);
+	return root;
+}
+
+int
+SMFSource::set_state (const XMLNode& node)
+{
+	const XMLProperty* prop;
+
+	if (MidiSource::set_state (node)) {
+		return -1;
+	}
+
+	if ((prop = node.property (X_("flags"))) != 0) {
+
+		int ival;
+		sscanf (prop->value().c_str(), "0x%x", &ival);
+		_flags = Flag (ival);
+
+	} else {
+
+		_flags = Flag (0);
+
+	}
+
+	assert(_name.find("/") == string::npos);
+
+	return 0;
+}
+
+void
+SMFSource::mark_for_remove ()
+{
+	if (!writable()) {
+		return;
+	}
+	_flags = Flag (_flags | RemoveAtDestroy);
+}
+
+void
+SMFSource::mark_streaming_write_completed ()
+{
+	if (!writable()) {
+		return;
+	}
+	
+	flush_footer();
+
+#if 0
+	Glib::Mutex::Lock lm (_lock);
+
+
+	next_peak_clear_should_notify = true;
+
+	if (_peaks_built || pending_peak_builds.empty()) {
+		_peaks_built = true;
+		 PeaksReady (); /* EMIT SIGNAL */
+	}
+#endif
+}
+
+void
+SMFSource::mark_take (string id)
+{
+	if (writable()) {
+		_take_id = id;
+	}
+}
+
+int
+SMFSource::move_to_trash (const string trash_dir_name)
+{
+	string newpath;
+
+	if (!writable()) {
+		return -1;
+	}
+
+	/* don't move the file across filesystems, just
+	   stick it in the 'trash_dir_name' directory
+	   on whichever filesystem it was already on.
+	*/
+
+	newpath = Glib::path_get_dirname (_path);
+	newpath = Glib::path_get_dirname (newpath);
+
+	newpath += '/';
+	newpath += trash_dir_name;
+	newpath += '/';
+	newpath += Glib::path_get_basename (_path);
+
+	if (access (newpath.c_str(), F_OK) == 0) {
+
+		/* the new path already exists, try versioning */
+		
+		char buf[PATH_MAX+1];
+		int version = 1;
+		string newpath_v;
+
+		snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
+		newpath_v = buf;
+
+		while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
+			snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
+			newpath_v = buf;
+		}
+		
+		if (version == 999) {
+			PBD::error << string_compose (_("there are already 1000 files with names like %1; versioning discontinued"),
+					  newpath)
+			      << endmsg;
+		} else {
+			newpath = newpath_v;
+		}
+
+	} else {
+
+		/* it doesn't exist, or we can't read it or something */
+
+	}
+
+	if (::rename (_path.c_str(), newpath.c_str()) != 0) {
+		PBD::error << string_compose (_("cannot rename midi file source from %1 to %2 (%3)"),
+				  _path, newpath, strerror (errno))
+		      << endmsg;
+		return -1;
+	}
+#if 0
+	if (::unlink (peakpath.c_str()) != 0) {
+		PBD::error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
+				  peakpath, _path, strerror (errno))
+		      << endmsg;
+		/* try to back out */
+		rename (newpath.c_str(), _path.c_str());
+		return -1;
+	}
+	    
+	_path = newpath;
+	peakpath = "";
+#endif	
+	/* file can not be removed twice, since the operation is not idempotent */
+
+	_flags = Flag (_flags & ~(RemoveAtDestroy|Removable|RemovableIfEmpty));
+
+	return 0;
+}
+
+// FIXME: Merge this with audiofilesource somehow (make a generic filesource?)
+bool
+SMFSource::find (string pathstr, bool must_exist, bool& isnew)
+{
+	string::size_type pos;
+	bool ret = false;
+
+	isnew = false;
+
+	/* clean up PATH:CHANNEL notation so that we are looking for the correct path */
+
+	if ((pos = pathstr.find_last_of (':')) == string::npos) {
+		pathstr = pathstr;
+	} else {
+		pathstr = pathstr.substr (0, pos);
+	}
+
+	if (pathstr[0] != '/') {
+
+		/* non-absolute pathname: find pathstr in search path */
+
+		vector<string> dirs;
+		int cnt;
+		string fullpath;
+		string keeppath;
+
+		if (_search_path.length() == 0) {
+			PBD::error << _("FileSource: search path not set") << endmsg;
+			goto out;
+		}
+
+		split (_search_path, dirs, ':');
+
+		cnt = 0;
+		
+		for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
+
+			fullpath = *i;
+			if (fullpath[fullpath.length()-1] != '/') {
+				fullpath += '/';
+			}
+			fullpath += pathstr;
+			
+			if (access (fullpath.c_str(), R_OK) == 0) {
+				keeppath = fullpath;
+				++cnt;
+			} 
+		}
+
+		if (cnt > 1) {
+
+			PBD::error << string_compose (_("FileSource: \"%1\" is ambigous when searching %2\n\t"), pathstr, _search_path) << endmsg;
+			goto out;
+
+		} else if (cnt == 0) {
+
+			if (must_exist) {
+				PBD::error << string_compose(_("Filesource: cannot find required file (%1): while searching %2"), pathstr, _search_path) << endmsg;
+				goto out;
+			} else {
+				isnew = true;
+			}
+		}
+		
+		_name = pathstr;
+		_path = keeppath;
+		ret = true;
+
+	} else {
+		
+		/* external files and/or very very old style sessions include full paths */
+		
+		_path = pathstr;
+		_name = pathstr.substr (pathstr.find_last_of ('/') + 1);
+		
+		if (access (_path.c_str(), R_OK) != 0) {
+
+			/* file does not exist or we cannot read it */
+
+			if (must_exist) {
+				PBD::error << string_compose(_("Filesource: cannot find required file (%1): %2"), _path, strerror (errno)) << endmsg;
+				goto out;
+			}
+			
+			if (errno != ENOENT) {
+				PBD::error << string_compose(_("Filesource: cannot check for existing file (%1): %2"), _path, strerror (errno)) << endmsg;
+				goto out;
+			}
+			
+			/* a new file */
+
+			isnew = true;
+			ret = true;
+
+		} else {
+			
+			/* already exists */
+
+			ret = true;
+		}
+	}
+	
+  out:
+	return ret;
+}
+
+void
+SMFSource::set_search_path (string p)
+{
+	_search_path = p;
+}
+
+
+void
+SMFSource::set_allow_remove_if_empty (bool yn)
+{
+	if (writable()) {
+		_allow_remove_if_empty = yn;
+	}
+}
+
+int
+SMFSource::set_name (string newname, bool destructive)
+{
+	//Glib::Mutex::Lock lm (_lock); FIXME
+	string oldpath = _path;
+	string newpath = Session::change_midi_path_by_name (oldpath, _name, newname, destructive);
+
+	if (newpath.empty()) {
+		PBD::error << string_compose (_("programming error: %1"), "cannot generate a changed midi path") << endmsg;
+		return -1;
+	}
+
+	if (rename (oldpath.c_str(), newpath.c_str()) != 0) {
+		PBD::error << string_compose (_("cannot rename midi file for %1 to %2"), _name, newpath) << endmsg;
+		return -1;
+	}
+
+	_name = Glib::path_get_basename (newpath);
+	_path = newpath;
+
+	return 0;//rename_peakfile (peak_path (_path));
+}
+
+bool
+SMFSource::is_empty (string path)
+{
+	/* XXX fix me */
+
+	return false;
+}
+
+
+void
+SMFSource::write_chunk_header(char id[4], uint32_t length)
+{
+	const uint32_t length_be = GUINT32_TO_BE(length);
+
+	fwrite(id, 1, 4, _fd);
+	fwrite(&length_be, 4, 1, _fd);
+}
+
+void
+SMFSource::write_chunk(char id[4], uint32_t length, void* data)
+{
+	write_chunk_header(id, length);
+	
+	fwrite(data, 1, length, _fd);
+}
+
+/** Returns the size (in bytes) of the value written. */
+size_t
+SMFSource::write_var_len(uint32_t value)
+{
+	size_t ret = 0;
+
+	uint32_t buffer = value & 0x7F;
+
+	while ( (value >>= 7) ) {
+		buffer <<= 8;
+		buffer |= ((value & 0x7F) | 0x80);
+	}
+
+	while (true) {
+		//printf("Writing var len byte %X\n", (unsigned char)buffer);
+		++ret;
+		fputc(buffer, _fd);
+		if (buffer & 0x80)
+			buffer >>= 8;
+		else
+			break;
+	}
+
+	return ret;
+}
+
+uint32_t
+SMFSource::read_var_len() const
+{
+	assert(!feof(_fd));
+
+	//int offset = ftell(_fd);
+	//cerr << "SMF - reading var len at " << offset << endl;
+
+	uint32_t value;
+	unsigned char c;
+
+	if ( (value = getc(_fd)) & 0x80 ) {
+		value &= 0x7F;
+		do {
+			assert(!feof(_fd));
+			value = (value << 7) + ((c = getc(_fd)) & 0x7F);
+		} while (c & 0x80);
+	}
+
+	return value;
+}
diff --git a/libs/ardour/sndfile_helpers.cc b/libs/ardour/sndfile_helpers.cc
index 9e439ba4c6..d47a9b9423 100644
--- a/libs/ardour/sndfile_helpers.cc
+++ b/libs/ardour/sndfile_helpers.cc
@@ -125,7 +125,7 @@ sndfile_endian_format_from_string (string str)
 
 string
 sndfile_file_ending_from_string (string str)
-{
+{	
 	static vector<string> file_endings;
 
 	if (file_endings.empty()) {
diff --git a/libs/ardour/sndfilesource.cc b/libs/ardour/sndfilesource.cc
index 24647030ab..8f795db111 100644
--- a/libs/ardour/sndfilesource.cc
+++ b/libs/ardour/sndfilesource.cc
@@ -578,8 +578,8 @@ SndFileSource::set_header_timeline_position ()
 		return;
 	}
 
-       _broadcast_info->time_reference_high = (timeline_position >> 32);
-       _broadcast_info->time_reference_low = (timeline_position & 0xffffffff);
+	_broadcast_info->time_reference_high = (timeline_position >> 32);
+	_broadcast_info->time_reference_low = (timeline_position & 0xffffffff);
 
 	if (sf_command (sf, SFC_SET_BROADCAST_INFO, _broadcast_info, sizeof (*_broadcast_info)) != SF_TRUE) {
 		error << string_compose (_("cannot set broadcast info for audio file %1; Dropping broadcast info for this file"), _path) << endmsg;
diff --git a/libs/ardour/source.cc b/libs/ardour/source.cc
index 7f680e7100..21cd871cbf 100644
--- a/libs/ardour/source.cc
+++ b/libs/ardour/source.cc
@@ -42,23 +42,30 @@ using std::max;
 
 using namespace ARDOUR;
 
-Source::Source (Session& s, string name)
+Source::Source (Session& s, string name, DataType type)
 	: _session (s)
+	, _type(type)
 {
+	assert(_name.find("/") == string::npos);
+
 	_name = name;
 	_timestamp = 0;
+	_length = 0;
 	_in_use = 0;
 }
 
 Source::Source (Session& s, const XMLNode& node) 
 	: _session (s)
+	, _type(DataType::AUDIO)
 {
 	_timestamp = 0;
+	_length = 0;
 	_in_use = 0;
 
-	if (set_state (node)) {
+	if (set_state (node) || _type == DataType::NIL) {
 		throw failed_constructor();
 	}
+	assert(_name.find("/") == string::npos);
 }
 
 Source::~Source ()
@@ -73,6 +80,7 @@ Source::get_state ()
 	char buf[64];
 
 	node->add_property ("name", _name);
+	node->add_property ("type", _type.to_string());
 	_id.print (buf, sizeof (buf));
 	node->add_property ("id", buf);
 
@@ -101,14 +109,27 @@ Source::set_state (const XMLNode& node)
 		return -1;
 	}
 
+	if ((prop = node.property ("type")) != 0) {
+		_type = DataType(prop->value());
+	}
+
 	if ((prop = node.property ("timestamp")) != 0) {
 		sscanf (prop->value().c_str(), "%ld", &_timestamp);
 	}
+	assert(_name.find("/") == string::npos);
 
 	return 0;
 }
 
 void
+Source::update_length (nframes_t pos, nframes_t cnt)
+{
+	if (pos + cnt > _length) {
+		_length = pos+cnt;
+	}
+}
+
+void
 Source::add_playlist (boost::shared_ptr<Playlist> pl)
 {
 	std::pair<PlaylistMap::iterator,bool> res;
diff --git a/libs/ardour/source_factory.cc b/libs/ardour/source_factory.cc
index 6ecd79844d..143d564809 100644
--- a/libs/ardour/source_factory.cc
+++ b/libs/ardour/source_factory.cc
@@ -24,6 +24,7 @@
 #include <ardour/sndfilesource.h>
 #include <ardour/silentfilesource.h>
 #include <ardour/configuration.h>
+#include <ardour/smf_source.h>
 
 #ifdef HAVE_COREAUDIO
 #include <ardour/coreaudiosource.h>
@@ -63,24 +64,38 @@ SourceFactory::createSilent (Session& s, const XMLNode& node, nframes_t nframes,
 boost::shared_ptr<Source>
 SourceFactory::create (Session& s, const XMLNode& node)
 {
-	try {
-		boost::shared_ptr<Source> ret (new CoreAudioSource (s, node));
-		if (setup_peakfile (ret)) {
-			return boost::shared_ptr<Source>();
-		}
-		SourceCreated (ret);
-		return ret;
-	} 
-
+	DataType type = DataType::AUDIO;
+	const XMLProperty* prop = node.property("type");
+	if (prop) {
+		type = DataType(prop->value());
+	}
 
-	catch (failed_constructor& err) {	
+	if (type == DataType::AUDIO) {
 
-		/* this is allowed to throw */
+		try {
+			boost::shared_ptr<Source> ret (new CoreAudioSource (s, node));
+			if (setup_peakfile (ret)) {
+				return boost::shared_ptr<Source>();
+			}
+			SourceCreated (ret);
+			return ret;
+		} 
 
-		boost::shared_ptr<Source> ret (new SndFileSource (s, node));
-		if (setup_peakfile (ret)) {
-			return boost::shared_ptr<Source>();
+		catch (failed_constructor& err) {
+		
+			/* this is allowed to throw */
+			
+			boost::shared_ptr<Source> ret (new SndFileSource (s, node));
+			if (setup_peakfile (ret)) {
+				return boost::shared_ptr<Source>();
+			}
+			SourceCreated (ret);
+			return ret;
 		}
+
+	} else if (type == DataType::MIDI) {
+
+		boost::shared_ptr<Source> ret (new SMFSource (node));
 		SourceCreated (ret);
 		return ret;
 	}
@@ -95,36 +110,68 @@ SourceFactory::create (Session& s, const XMLNode& node)
 {
 	/* this is allowed to throw */
 
-	boost::shared_ptr<Source> ret (new SndFileSource (s, node));
+	DataType type = DataType::AUDIO;
+	const XMLProperty* prop = node.property("type");
+	if (prop) {
+		type = DataType(prop->value());
+	}
 	
-	if (setup_peakfile (ret)) {
-		return boost::shared_ptr<Source>();
+	if (type == DataType::AUDIO) {
+		
+		boost::shared_ptr<Source> ret (new SndFileSource (s, node));
+
+		if (setup_peakfile (ret)) {
+			return boost::shared_ptr<Source>();
+		}
+		
+		SourceCreated (ret);
+		return ret;
+
+	} else if (type == DataType::MIDI) {
+
+		boost::shared_ptr<Source> ret (new SMFSource (s, node));
+		
+		SourceCreated (ret);
+		return ret;
+
 	}
 	
-	SourceCreated (ret);
-	return ret;
+	return boost::shared_ptr<Source> ();
 }
 
 #endif // HAVE_COREAUDIO
 
 #ifdef HAVE_COREAUDIO
 boost::shared_ptr<Source>
-SourceFactory::createReadable (Session& s, string path, int chn, AudioFileSource::Flag flags, bool announce)
+SourceFactory::createReadable (DataType type, Session& s, string path, int chn, AudioFileSource::Flag flags, bool announce)
 {
-	if (!(flags & Destructive)) {
-
-		try {
-			boost::shared_ptr<Source> ret (new CoreAudioSource (s, path, chn, flags));
-			if (setup_peakfile (ret)) {
-				return boost::shared_ptr<Source>();
+	if (type == DataType::AUDIO) {
+		if (!(flags & Destructive)) {
+
+			try {
+				boost::shared_ptr<Source> ret (new CoreAudioSource (s, path, chn, flags));
+				if (setup_peakfile (ret)) {
+					return boost::shared_ptr<Source>();
+				}
+				if (announce) {
+					SourceCreated (ret);
+				}
+				return ret;
 			}
-			if (announce) {
-				SourceCreated (ret);
+
+			catch (failed_constructor& err) {
+				boost::shared_ptr<Source> ret (new SndFileSource (s, path, chn, flags));
+				if (setup_peakfile (ret)) {
+					return boost::shared_ptr<Source>();
+				}
+				if (announce) {
+					SourceCreated (ret);
+				}
+				return ret;
 			}
-			return ret;
-		}
-		
-		catch (failed_constructor& err) {
+
+		} else {
+
 
 			/* this is allowed to throw */
 
@@ -138,16 +185,15 @@ SourceFactory::createReadable (Session& s, string path, int chn, AudioFileSource
 			return ret;
 		}
 
-	} else {
+		return boost::shared_ptr<Source>();
+	} else if (type == DataType::MIDI) {
 
-		boost::shared_ptr<Source> ret (new SndFileSource (s, path, chn, flags));
-		if (setup_peakfile (ret)) {
-			return boost::shared_ptr<Source>();
-		}
+		boost::shared_ptr<Source> ret (new SMFSource (s, node));
 		if (announce) {
 			SourceCreated (ret);
 		}
 		return ret;
+
 	}
 
 	return boost::shared_ptr<Source>();
@@ -156,41 +202,72 @@ SourceFactory::createReadable (Session& s, string path, int chn, AudioFileSource
 #else
 
 boost::shared_ptr<Source>
-SourceFactory::createReadable (Session& s, string path, int chn, AudioFileSource::Flag flags, bool announce)
+SourceFactory::createReadable (DataType type, Session& s, string path, int chn, AudioFileSource::Flag flags, bool announce)
 {
-	boost::shared_ptr<Source> ret (new SndFileSource (s, path, chn, flags));
+	if (type == DataType::AUDIO) {
+	
+		boost::shared_ptr<Source> ret (new SndFileSource (s, path, chn, flags));
 
-	if (setup_peakfile (ret)) {
-		return boost::shared_ptr<Source>();
-	}
+		if (setup_peakfile (ret)) {
+			return boost::shared_ptr<Source>();
+		}
 
-	if (announce) {
-		SourceCreated (ret);
+		if (announce) {
+			SourceCreated (ret);
+		}
+
+		return ret;
+
+
+	} else if (type == DataType::MIDI) {
+
+		// FIXME: flags?
+		boost::shared_ptr<Source> ret (new SMFSource (s, path, SMFSource::Flag(0)));
+
+		if (announce) {
+			SourceCreated (ret);
+		}
+
+		return ret;
 	}
 
-	return ret;
+	return boost::shared_ptr<Source>();
 }
 
 #endif // HAVE_COREAUDIO
 
 boost::shared_ptr<Source>
-SourceFactory::createWritable (Session& s, std::string path, bool destructive, nframes_t rate, bool announce)
+SourceFactory::createWritable (DataType type, Session& s, std::string path, bool destructive, nframes_t rate, bool announce)
 {
 	/* this might throw failed_constructor(), which is OK */
 
-	boost::shared_ptr<Source> ret (new SndFileSource 
-				       (s, path, 
-					Config->get_native_file_data_format(),
-					Config->get_native_file_header_format(),
-					rate,
-					(destructive ? AudioFileSource::Flag (SndFileSource::default_writable_flags | AudioFileSource::Destructive) :
-					 SndFileSource::default_writable_flags)));	
+	if (type == DataType::AUDIO) {
+		boost::shared_ptr<Source> ret (new SndFileSource 
+				(s, path, 
+				 Config->get_native_file_data_format(),
+				 Config->get_native_file_header_format(),
+				 rate,
+				 (destructive ? AudioFileSource::Flag (SndFileSource::default_writable_flags | AudioFileSource::Destructive) :
+				  SndFileSource::default_writable_flags)));	
+
+		if (setup_peakfile (ret)) {
+			return boost::shared_ptr<Source>();
+		}
+		if (announce) {
+			SourceCreated (ret);
+		}
+		return ret;
+
+	} else if (type == DataType::MIDI) {
+
+		boost::shared_ptr<Source> ret (new SMFSource (s, path));
+		
+		if (announce) {
+			SourceCreated (ret);
+		}
+		return ret;
 
-	if (setup_peakfile (ret)) {
-		return boost::shared_ptr<Source>();
-	}
-	if (announce) {
-		SourceCreated (ret);
 	}
-	return ret;
+
+	return boost::shared_ptr<Source> ();
 }
diff --git a/libs/ardour/sse_functions_xmm.cc b/libs/ardour/sse_functions_xmm.cc
index 5554462132..9b37c37912 100644
--- a/libs/ardour/sse_functions_xmm.cc
+++ b/libs/ardour/sse_functions_xmm.cc
@@ -22,7 +22,7 @@
 #include <ardour/types.h>
 
 void
-x86_sse_find_peaks(float *buf, nframes_t nframes, float *min, float *max)
+x86_sse_find_peaks(const ARDOUR::Sample* buf, nframes_t nframes, float *min, float *max)
 {
 	__m128 current_max, current_min, work;
 
diff --git a/libs/ardour/track.cc b/libs/ardour/track.cc
index 95e21e6735..a5484813f9 100644
--- a/libs/ardour/track.cc
+++ b/libs/ardour/track.cc
@@ -83,12 +83,12 @@ Track::get_template ()
 void
 Track::toggle_monitor_input ()
 {
-	for (vector<Port*>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
-		(*i)->ensure_monitor_input(!(*i)->monitoring_input());
+	for (PortSet::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
+		i->ensure_monitor_input(!i->monitoring_input());
 	}
 }
 
-nframes_t
+ARDOUR::nframes_t
 Track::update_total_latency ()
 {
 	_own_latency = 0;
@@ -147,8 +147,8 @@ bool
 Track::can_record()
 {
 	bool will_record = true;
-	for (size_t i = 0; i < _inputs.size() && will_record; i++) {
-		if (!_inputs[i]->connected())
+	for (PortSet::iterator i = _inputs.begin(); i != _inputs.end() && will_record; ++i) {
+		if (!i->connected())
 			will_record = false;
 	}
 
diff --git a/libs/ardour/utils.cc b/libs/ardour/utils.cc
index 6b5ea2cef6..51a0414d0c 100644
--- a/libs/ardour/utils.cc
+++ b/libs/ardour/utils.cc
@@ -17,6 +17,9 @@
 
 */
 
+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+
 #include <cstdio> /* for sprintf */
 #include <cmath>
 #include <cctype>
@@ -233,6 +236,12 @@ path_is_paired (ustring path, ustring& pair_base)
 {
 	ustring::size_type pos;
 
+	/* remove any leading path */
+
+	if ((pos = path.find_last_of ('/')) != string::npos) {
+		path = path.substr(pos+1);
+	}
+
  	/* remove filename suffixes etc. */
 	
 	if ((pos = path.find_last_of ('.')) != string::npos) {
diff --git a/libs/cairomm/AUTHORS b/libs/cairomm/AUTHORS
deleted file mode 100644
index 2c4d00679a..0000000000
--- a/libs/cairomm/AUTHORS
+++ /dev/null
@@ -1,10 +0,0 @@
-Please do not email us directly - use the mailing list.
-See http://cairographics.org/lists
-
-Maintainers:
-----------
-Murray Cumming
-Jonathon Jongsma
-
-Based on code from Leonard Ritter.
-
diff --git a/libs/cairomm/ChangeLog b/libs/cairomm/ChangeLog
deleted file mode 100644
index c78ed89c0a..0000000000
--- a/libs/cairomm/ChangeLog
+++ /dev/null
@@ -1,724 +0,0 @@
-1.2.4:
-
-2007-01-17  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* NEWS: updated news for 1.2.4 release
-	* configure.in: bumped version to 1.2.4
-
-2006-09-27  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/refptr.h: cast_static() and cast_dynamic(): 
-	Use the refcount_() accessor instead of the member variable, 
-	to avoid compilation errors, as we already do in the 
-	templated copy constructor.
-
-1.2.2:
-
-2006-08-21  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* NEWS: update for 1.2.2
-	* configure.in: bump to next even number (1.2.2)
-
-2006-08-21  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* cairomm/win32_surface.cc: Explicitly cast Cairo::Format to
-	cairo_format_t.
-	
-2006-08-20  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* Makefile.am: fix up the release announcement template to explain what
-	cairomm is at the top of the email before telling where to get it.
-	* configure.in: post-release bump (1.2.1)
-
-1.2.0:
-
-2006-08-20  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* NEWS: Update information about new stuff in 1.2.0
-	* configure.in: bump the release version number to 1.2.0 and the shared
-	library version number to 1:0:0 since interfaces were changed and added and
-	we're now guaranteeing API/ABI stability
-
-2006-08-20  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/pdf-surface/.cvsignore:
-	* examples/png_file/.cvsignore:
-	* examples/ps-surface/.cvsignore:
-	* examples/svg-surface/.cvsignore: added image files produced by the example
-	programs to .cvsignore
-
-2006-08-19  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* Makefile.am: get rid of the concept of a snapshot.  It doesn't really make
-	that much sense for cairomm, honestly, since we're just a simple wrapper
-	library.
-
-2006-08-19  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* MSVC/examples/.cvsignore:
-	* MSVC/examples/Makefile.am:
-	* MSVC/examples/pdf-surface/.cvsignore:
-	* MSVC/examples/pdf-surface/Makefile.am:
-	* MSVC/examples/pdf-surface/pdf-surface.vcproj:
-	* MSVC/examples/png_file/.cvsignore:
-	* MSVC/examples/png_file/Makefile.am:
-	* MSVC/examples/png_file/png_file.vcproj:
-	* MSVC/examples/ps-surface/.cvsignore:
-	* MSVC/examples/ps-surface/Makefile.am:
-	* MSVC/examples/ps-surface/ps-surface.vcproj:
-	* MSVC/examples/svg-surface/.cvsignore:
-	* MSVC/examples/svg-surface/Makefile.am:
-	* MSVC/examples/svg-surface/svg-surface.vcproj:
-	* MSVC/examples/text-rotate/.cvsignore:
-	* MSVC/examples/text-rotate/Makefile.am:
-	* MSVC/examples/text-rotate/text-rotate.vcproj:
-	* MSVC/gendef/.cvsignore:
-	* MSVC/gendef/Makefile.am:
-	* MSVC/gendef/gendef.cc:
-	* MSVC/gendef/gendef.vcproj: added a bunch of MSVC / windows-specific things
-	that got missed last time.
-
-2006-08-18  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/win32_surface.cc:
-	* cairomm/win32_surface.h: add some missing win32 API that I had overlooked:
-	cairo_win32_surface_get_dc() and cairo_win32_surface_create_with_dib(),
-	updated documentation for standard Win32Surface::create() function.
-
-2006-08-18  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* cairomm/context.cc: Define M_PI for MSVC.
-	* cairomm/scaledfont.cc: Allocate glyph_array as a synamic array
-	as MSVC does not like non-const arguments as array size.
-	* examples/pdf-surface/main.cc, examples/png_file/main.cc,
-	examples/ps-surface/main.cc, examples/svg-surface/main.cc,
-	examples/text-rotate/text-rotate.cc: Define M_PI for MSVC. 
-	* configure.in, Makefile.am: Generate Makefiles in the MSVC
-	subdirectories.  
-	* .cvsignore: Added Eclipse .project to the list of ignored files.
-	* MSVC/*: Added project and resource files for Visual Studio 2005.
-	
-2006-08-18  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h: API CHANGE: some API was changed to maintain a closer
-	similarity to the underlying cairo API (while also attempting to avoid
-	confusion with the C++ 'new' keyword) in preparation for freezing the
-	cairomm API.  Two functions are affected:
-		- Context::clear_path() -> Context::begin_new_path()
-		- Context::new_sub_path() -> Context::begin_new_sub_path()
-	* configure.in: bump the libtool version to indicate API change
-
-2006-08-15  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/context.cc: remove another TODO.  I looked at cairo_append_path,
-	and it just copies the data from the supplied path and appends that to the
-	current path -- it doesn't modify the passed in path -- so it can stay
-	const.
-
-2006-08-15  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/context.h: remove a FIXME that was resolved on the mailing list
-
-2006-07-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/refptr.h: unref(): Only delete the refcount int when the refcount has 	
-	reached 0, instead of deleting it every time. Thanks valgrind.
-
-2006-07-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/refptr.h: From-C-object Constructor: Added documentation explaining 
-	how/when to use it and when to do an extra reference(). This will help us, 
-	though it should rarely be necessary for an application developer to understand 
-	it.
-	Made pCppRefcount_ mutable, so that refcount_() can be a const method so that 
-	the templated constructor compiles.
-	Added class documentation to explain why we even want to use this class.
-
-2006-07-05  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/refptr.h: copy constructors: initialize the pCppRefcount_ member 
-	variable, using a public refcount_() method when necessary to access a 
-	different RefPtr<> specialization.
-
-2006-07-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/refptr.h: Use an int to reference-count the C++ object, and 
-	only reference/unreference the object (and hence the underlying C object) 
-	when receiving/deleting the C++ object. Without this, we never delete 
-	the C++ object. Fixes bug #7442.
-
-2006-07-09  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* NEWS: add NEWS for 1.1.10 release
-	* configure.in: bump version to 1.1.12
-
-2006-07-05  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* Makefile.am: Ooops, I had accidentally removed dependency info for
-	release-publish target
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/context.h:
-	* cairomm/fontface.h:
-	* cairomm/pattern.h:
-	* cairomm/surface.cc:
-	* cairomm/surface.h:
-	* cairomm/xlib_surface.cc:
-	* cairomm/xlib_surface.h: Fix the generic text about reference-counted 
-	objects, because we no longer use copy constructors for this. And some 
-	pedantic white space changes.
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/scaledfont.cc:
-	* cairomm/scaledfont.h: create(): Make the font_matrix and ctm 
-	parameters const (they are now const in the C API too). Maybe the font 
-	parameter should be const, but maybe there is a reason that it is not 
-	const in the C API. Pass FontOptions by const reference instead of 
-	by value.
-	glyph_extents(): Pass the vector by const reference instead of by 
-	value.
-	I would prefere to make all the extents() functions use return values 
-	instead of output parameters, but I suppose this might be slightly 
-	less efficient in some circumstances.
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/cairomm.h:
-	* cairomm/context.h:
-	* cairomm/path.h:
-	* cairomm/scaledfont.h:
-	* cairomm/surface.h:
-	* cairomm/win32_surface.h:
-	* cairomm/xlib_surface.h: Use @ instead of \ for doxygen 
-	commands, to be consistent with gtkmm, which uses it because it is the 
-	same as JavaDoc, with which some people are already familiar.
-
-2006-07-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* Makefile.am: add ability to do snapshot releases to the
-	cairographics.org/snapshots/ directory in addition to official releases
-	* configure.in: bumped the revision to 1.1.10 in preparation for a snapshot
-	release of the 1.2 API
-	* docs/reference/Makefile.am: fixed some distcheck errors
-
-2006-07-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* .cvsignore, cairomm/.cvsignore: ignore some autotools files and *.swp
-	files (from vim)
-
-2006-07-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/scaledfont.cc, cairomm/scaledfont.h: wrap ScaledFont, including
-	new API for cairo 1.2
-	* cairomm/Makefile.am: add scaledfont.* to list of sources
-
-2006-07-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/surface.h: Remove comments stating that PDF, PS, and SVG are
-	experimental surfaces.  As of 1.2.0, these three surfaces are officially
-	supported by the cairo library.
-
-2006-07-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/xlib_surface.h: add a bit more documentation for the new
-	XlibSurface API
-
-2006-07-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/surface.cc, cairomm/surface.h: added SvgSurface::get_versions()
-	and SvgSurface::version_to_string() API.  They're implemented as static
-	members right now.
-
-2006-06-30  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in: bumped cairomm version to 0.7.0 and bumped cairo requirement
-	to 1.2.0
-
-2006-06-30  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/xlib_surface.cc, cairomm/xlib_surface.h: add new get_height() and
-	get_width() API to XlibSurface
-
-2006-06-27  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/enums.h: Added enum types to support the new get_type() and SVG
-	Version API 
-	* cairomm/fontface.cc, cairomm/fontface.h: add new get_type() API
-	* cairomm/pattern.cc, cairomm/pattern.h: add new get_type() API
-	* cairomm/surface.cc, cairomm/surface.h: add new get_type() API and
-	SvgSurface::restrict_to_version() API
-
-2006-06-26  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/surface.cc, cairomm/surface.h: add new PsSurface and PdfSurface
-	API: set_size, dsc_comment, dsc_begin_setup, dsc_begin_page_setup
-	* cairomm/xlib_surface.cc, cairomm/xlib_surface.h: add new XlibSurface API:
-	get_display, get_drawable, get_screen, get_visual, get_depth
-
-2006-06-26  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/surface.cc:
-	* cairomm/surface.h: Added new Surface and ImageSurface API from 1.1.x
-	snapshots
-
-2006-06-23  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h: added Context::new_sub_path() and new push/pop group
-	API.
-
-2006-06-23  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/enums.h: fix stupid error from last commit
-
-2006-06-23  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/enums.h: add new FORMAT_RGB16_565 format
-
-2006-06-12  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in: bump required cairo version to >= 1.1.7
-	* cairomm/surface.cc, cairomm/surface.h: update to new cairo API
-	cairo_surface_set_fallback_resolution
-
-2006-05-10  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/reference/cairomm.css: minor documentation stylesheet fix
-
-2006-05-08  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/context.h:
-	* cairomm/path.h: added some preliminary documentation explaining that the
-	caller is responsible for freeing Path objects returned from
-	Context::copy_path() and Context::copy_path_flat().
-
-2006-05-08  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/cairomm.h: Add doxygen API introduction test here.
-	* docs/reference/Doxyfile.in: 
-	* docs/reference/Makefile.am:
-	* docs/reference/cairomm-header.html:
-	* docs/reference/cairomm.css:
-	* docs/reference/introduction.h: fix up some documentation presentation
-	issues that turned up with newer versions of doxygen.
-
-2006-05-08  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in: remove check for perl since we're not using any of the
-	gmmproc stuff for cairomm
-	* docs/reference/Makefile.am: add documentation dependency on all of the
-	headers in the cairomm/ directory so that if a header changes the
-	documentation will be rebuilt.
-
-2006-04-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h: mask(pattern) and mask(surface): Make the parameter 
-	const, because I am fairly sure that the C function does not change it.
-
-2006-04-06  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* Makefile.am: Add a brief description of cairomm to the release
-	announcement template
-
-2006-04-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/reference/Doxyfile.in:
-	* docs/reference/Makefile.am: A couple minor build fixes to make distcheck
-	happy
-
-2006-04-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* NEWS: add news for 0.6.0 release
-	* configure.in: bump version to 0.6.0
-
-2006-04-03  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/text-rotate/text-rotate.cc: protect PNG functions with #ifdef in
-	case cairo wasn't compiled with PNG support
-
-2006-03-31  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* Makefile.am:
-	* docs/Makefile.am:
-	* docs/reference/Makefile.am: add convenience targets for cleaning and
-	rebuilding documentation (doc-clean and doc-rebuild).
-
-2006-03-30  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* configure.in: enable documentation even if doxygen and/or graphviz
-	are missing, so the docs will be installed when building a release.
-	* docs/reference/Makefile.am: don't remove html directory with `make clean`,
-	so that users of the tarball releases don't destroy the pre-built
-	documentation when running make clean. Change to maintainer-clean
-
-2006-03-29  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in: added tests for doxygen and graphviz which displays a
-	warning if the user has --enable-docs set but doesn't have doxygen or
-	graphviz installed.  
-
-2006-03-28  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* cairomm/enums.h: Stop using CAIRO_EXTEND_PAD, as it only exists
-	in the 1.1.1 development branch.
-
-2006-03-14  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in:
-	* examples/Makefile.am:
-	* examples/text-rotate/.cvsignore:
-	* examples/text-rotate/Makefile.am:
-	* examples/text-rotate/text-rotate.cc: Added another basic example,
-	borrowed from a test-case in cairo.  This one is just a simple example of
-	using text in cairomm
-
-2006-03-14  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/fontface.h:
-	* cairomm/fontoptions.h:
-	* cairomm/path.h:
-	* cairomm/pattern.h: include <cairo.h> instead of <cairo/cairo.h> since it
-	didn't want to compile on windows without these
-	* cairomm/win32_surface.cc:
-	* cairomm/win32_surface.h: Move the include of cairo-win32.h from the
-	source file to the header since the declaration of create() needs the HDC
-	type definition.
-	With these changes, cairomm should compile the Win32Surface cleanly with
-	mingw on Microsoft Windows
-
-2006-03-12  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* autogen.sh: Allow overriding aclocal, automake, autoconf and libtoolize
-	using environment variables. Taken from cairo's autogen.sh.
-
-2006-03-06  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/*.cc, *.h: add vim modelines to set proper indentation for
-	cairomm when using vim
-
-2006-02-28  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h:
-	* cairomm/enums.h:
-	* cairomm/fontoptions.cc:
-	* cairomm/fontoptions.h:
-	* cairomm/pattern.cc:
-	* cairomm/pattern.h:
-	* cairomm/surface.h: wrapped all of the enum types with cairomm
-	types within the Cairo namespace, so now (for example) the values for
-	Cairo::Format are something like Cairo::FORMAT_ARGB32 instead of the base
-	cairo types like CAIRO_FORMAT_ARGB_32.
-	* examples/png_file/main.cc: fixed example to work with the new namespaced
-	enum types
-
-2006-02-27  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/exception.h:
-	* docs/reference/Doxyfile.in:
-	* docs/reference/Makefile.am: hide some of the private types and functions
-	from the Doxygen API reference documentation
-
-2006-02-27  Stefan Kersten  <steve@k-hornz.de>
-
-	* cairomm/surface.cc: fix an extra trailing parentheses in
-	GlitzSurface::create()
-
-2006-02-22  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* examples/README: Write some basic information about each example
-
-2006-02-22  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/reference/Makefile.am: add target for publishing the API reference
-	to cairographics.org
-
-2006-02-20  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* Makefile.am: Include MAINTAINERS in distribution. Fixes Bug #5982
-
-2006-02-17  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* COPYING: Use the text from the Library GPL 2.0, which is the actual
-	license of cairomm. Fixes Bug #5934
-
-2006-02-17  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* autogen.sh:
-	* cairomm/cairomm.h:
-	* cairomm/context.cc:
-	* cairomm/context.h:
-	* cairomm/enums.h:
-	* cairomm/exception.cc:
-	* cairomm/exception.h:
-	* cairomm/fontface.cc:
-	* cairomm/fontface.h:
-	* cairomm/fontoptions.cc:
-	* cairomm/fontoptions.h:
-	* cairomm/path.cc:
-	* cairomm/path.h:
-	* cairomm/pattern.cc:
-	* cairomm/pattern.h:
-	* cairomm/private.cc:
-	* cairomm/private.h:
-	* cairomm/refptr.h:
-	* cairomm/surface.cc:
-	* cairomm/surface.h:
-	* cairomm/win32_surface.cc:
-	* cairomm/win32_surface.h:
-	* cairomm/xlib_surface.cc:
-	* cairomm/xlib_surface.h: Update FSF's postal address in GPL/LGPL
-	comment headings.  Fixes Bug #5933
-
-2006-02-17  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* examples/*/.cvsignore: Bug #5927: added .cvsignore files to examples
-	directories
-
-2006-02-17  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* AUTHORS:
-	* INSTALL:
-	* README:
-	* cairomm/exception.cc:
-	* cairomm/exception.h: Remove lingering references to libxml++
-
-2006-02-17  Danilo Piazzalunga  <danilopiazza@gmail.com>
-
-	* configure.in: Bug #5929: Output files in docs subdir only if
-	--enable-docs is set.  This prevents configure from generating files which
-	are not cleaned up when --disable-docs is used.
-	Use AC_CONFIG_FILES and AC_OUTPUT as recommended.
-
-2006-02-16  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/reference/Doxyfile.in:
-	* docs/reference/cairomm.css: added some style customisations to the API
-	doc so that it fits in with the overall Cairo style a bit better
-
-2006-02-16  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* AUTHORS:
-	* MAINTAINERS: Add my information to the Maintainers and authors file
-
-0.5.0:
-
-2006-02-09  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/reference/Makefile.am: added a 'html' target to satisfy the dist
-	rule
-
-2006-02-08  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/context.h: Added a lot of documentation for the Cairo::Context
-	class taken from the cairo docs.  It's not complete, but the basics are all
-	covered now. 
-	* docs/reference/Makefile.am: make use of existing Makefile variable
-	* NEWS: update for 0.5.0 release
-
-2006-02-07  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* Makefile.am: add docs/ subdir
-	* configure.in: added an --enable-docs switch to the configure script
-	(enabled by default), and added AC_OUTPUT directives for the documentation
-	Makefiles, etc.
-	* docs/.cvsignore:
-	* docs/Makefile.am:
-	* docs/reference/.cvsignore:
-	* docs/reference/Doxyfile.in:
-	* docs/reference/Makefile.am:
-	* docs/reference/introduction.h: Added infrastructure to build and install
-	the API documentation for cairomm (based on libxml++ makefiles).  
-
-2006-01-27  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* .cvsignore:
-	* cairomm/.cvsignore: update .cvsignore files
-	* cairomm/surface.cc:
-	* cairomm/surface.h: change Surface::create function to take a
-	RefPtr<Surface> instead of Surface&
-
-2006-01-27  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/pdf-surface/Makefile.am: Remove extra LDADD that was breaking 
-	the distcheck.
-
-2006-01-26  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/ps-surface/main.cc:
-	* examples/svg-surface/main.cc: Correct the text of the messages.
-
-2006-01-25  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in:
-	* examples/Makefile.am: 
-	* examples/pdf-surface/: 
-	* examples/ps-surface/: 
-	* examples/svg-surface/: add examples for additional surfaces
-
-2006-01-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/Makefile.am:
-	* cairomm/surface.cc:
-	* cairomm/surface.h:
-	* cairomm/xlib_surface.cc:
-	* cairomm/xlib_surface.h:
-	* cairomm/win32_surface.cc:
-	* cairomm/win32_surface.h: Moved XlibSurface and 
-	Win32Surface into separate files, not #included by 
-	the main cairomm.h file, so that developers do not need to 
-	suffer the Xlib.h or Windows namespace pollution unless they really need to. 
-	For instance, this fixes the gtkmm 2.9 build which was broken by the 
-	Display struct in Xlib.h.
-
-2006-01-15  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/surface.cc:
-	* cairomm/surface.h: backwards-incompatible API change for the Surface
-	types.  Cairo::Surface is now a base class for all of the other surface
-	types, and should not be used directly.  New Surface types include
-	ImageSurface, XlibSurface, Win32Surface, PdfSurface, PsSurface,
-	SvgSurface, and GlitzSurface.  
-	Modified Surface::write_to_png() and Surface::write_to_png_stream() so
-	that they throw exceptions like the other functions instead of returning a
-	cairo_status_t value.
-	Added API documentation for all Surface classes and all member functions
-	of the Surface class heirarchy.
-	* examples/png_file/Makefile.am: added generated PNG file to CLEANFILES
-	* examples/png_file/main.cc: updated the PNG example to use the new
-	ImageSurface class instead of using the Surface class directly.
-	* cairomm/*: Renamed the Cairo::Status type to Cairo::ErrorStatus since it
-	conflicts with a #define Status in XLib and is not used exposed in the API
-	anyway.
-
-2006-01-06  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/surface.cc:
-	* cairomm/surface.h: Added implementation of write_to_png() and
-	write_to_png_stream() when PNG support is available in the base cairo
-	library
-	* examples/png_file/*: Added an example of creating an image surface and
-	saving it to a png image file
-	* examples/Makefile.am: add new example directory to SUBDIRS list
-	* configure.in: added output declaration for examples/png_file/Makefile
-	* examples/makefile.am_fragment: fix leftover libxml boilerplate
-
-2006-01-03  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* cairomm/surface.cc: added missing implementations for reference() and
-	unreference() functions
-
-0.4.0:
-
-2005-12-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/Makefile.am:
-	* cairomm/refptr.h: Add shared 
-	reference-counting smartpointer, using 
-	the reference-count in the object. A copy 
-	of the tried and tested glibmm RefPtr.
-	* cairomm/context.cc:
-	* cairomm/context.h:
-	* cairomm/fontface.cc:
-	* cairomm/fontface.h:
-	* cairomm/pattern.cc:
-	* cairomm/pattern.h:
-	* cairomm/surface.cc:
-	* cairomm/surface.h: Make constructors protected 
-	and add public static create() methods that return 
-	instances in RefPtr<>s. This allows reference-counted 
-	objects to be clearly const or non-const, and allows 
-	casting between related types.
-
-2005-12-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h: Change set_dash(void) to 
-	unset_dash(). Change rotate_deg() to 
-	rotate_degrees(). Change identity_matrix() to 
-	set_identity_matrix(). Change new_path() to 
-	clear_path().
-	* cairomm/fontface.cc:
-	* cairomm/fontface.h: Comment-out 
-	get/set_user_data(), because it seems useless.
-
-0.3.0:
-
-2005-12-08  Murray Cumming <murrayc@murrayc.com>
-
-	* cairomm/pattern.cc:
-	* cairomm/pattern.h: Create a hierarchy of pattern 
-	classes, as suggested by the C documentation, because 
-	not all functions are meaningful for all pattern types.
-
-2005-12-07  Murray Cumming <murrayc@murrayc.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h: font_extents(), stroke_extents(), 
-	glyph_extents(), fill_extents(): Add get_ prefix and 	
-	make them const.
-
-2005-12-07  Murray Cumming <murrayc@murrayc.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h: Add typedef for Matrix, though we 
-	probably want to derive a class with a C++-like matrix 
-	API, with operator overloading.
-
-2005-12-07  Murray Cumming <murrayc@murrayc.com>
-
-	* cairomm/exception.cc:
-	* cairomm/exception.h: Rename to logic_error, because 
-	the cairo documentation says that most of them are 
-	programming errors, not runtime errors. Derive from 
-	std::logic_error because of this.
-	* cairomm/private.cc:
-	* cairomm/private.h: Throw std::bad_alloc for memory 
-	errors, and std::io_base::failure for read/write runtime 
-	errors, as suggested by the cairo language-binding 
-	documentation.
-
-2005-12-07  Murray Cumming <murrayc@murrayc.com>
-
-	* cairomm/context.cc:
-	* cairomm/fontoptions.cc:
-	* cairomm/surface.cc: Check for errors in 
-	constructors, as per the error-handling advice in the 
-	language bindings section of the cairo documentation.
-
-2005-12-07  Murray Cumming <murrayc@murrayc.com>
-
-	* cairomm/context.cc:
-	* cairomm/context.h: Change mask_surface() to 
-	mask() and set_source_surface() to set_source(), 
-	as per the method overloading advice in the 
-	language bindings section of the cairo documentation.
-
-0.2.0:
-
-2005-12-02  Murray Cumming <murrayc@murrayc.com>
-
-	* cairomm/cairomm.h: Put sensible stuff in here, 
-	instead of my copy/paste stuff from libxml++.
-	* cairomm/context.cc:
-	* cairomm/context.h:
-	* cairomm/enums.h:
-	* cairomm/exception.cc:
-	* cairomm/exception.h:
-	* cairomm/fontface.cc:
-	* cairomm/fontface.h:
-	* cairomm/fontoptions.cc:
-	* cairomm/fontoptions.h:
-	* cairomm/path.cc:
-	* cairomm/path.h:
-	* cairomm/pattern.cc:
-	* cairomm/pattern.h:
-	* cairomm/private.cc:
-	* cairomm/private.h:
-	* cairomm/surface.cc:
-	* cairomm/surface.h: Add LGPL comment headings.
-
diff --git a/libs/cairomm/MAINTAINERS b/libs/cairomm/MAINTAINERS
deleted file mode 100644
index 54d06c9176..0000000000
--- a/libs/cairomm/MAINTAINERS
+++ /dev/null
@@ -1,8 +0,0 @@
-Please use the mailing list (cairo@cairographics.org) rather than emailing
-developers directly.
-
-Murray Cumming
-Email: murrayc@murrayc.com
-
-Jonathon Jongsma
-Email: jonathon.jongsma@gmail.com
diff --git a/libs/cairomm/NEWS b/libs/cairomm/NEWS
deleted file mode 100644
index f30a2c5a9e..0000000000
--- a/libs/cairomm/NEWS
+++ /dev/null
@@ -1,81 +0,0 @@
-1.2.4:
-
- * Fixed an error that prevented Cairo::RefPtr<>::cast_static() and
-   Cairo::RefPtr<>::cast_dynamic() from compiling.
-
-1.2.2:
-
-* Fixed an issue when compiling on windows with MSVC
-
-1.2.0:
-
-* This is the first release that guarantees API and ABI stability
-* Changed API:
-  - Context::clear_path() is now Context::begin_new_path()
-  - Context::new_sub_path() is now Context::begin_new_sub_path()
-* new API:
-  - Win32Surface::get_dc()
-  - Win32Surface::create() for device-independent bitmaps
-* Bugfixes
-  - fixed a memory leak where C++ wrapper objects were not being destroyed
-* Fixes for compiling with MSVC (also includes project and resource files for
-  Visual Studio 2005.  See the MSVC/ directory)
-
-1.1.10:
-
-* API:
-  - Wrap new API from cairo 1.2
-  - Wrap ScaledFont
-* Improved Documentation
-* Build fixes
-
-0.6.0:
-
-* API:
-  - enumerations are now wrapped within the Cairo namespace.  So, for example,
-    CAIRO_FORMAT_ARGB32 becomes Cairo::FORMAT_ARGB32
-* Examples: added simple text example translated from Cairo.
-* Bugfixes for the Glitz and Windows backends. 
-* Build and installation improvements (Danilo Piazzalunga)
-
-0.5.0:
-
-* Surface:
-  - Created derived classes for PDF, PS, SVG, Glitz, 
-  X11 and Win32 surfaces, which are only available if your copy 
-  of cairo supports those surfaces. The X11 and Win32 Surface headers 
-  must be #included explicitly.
-  (Jonathon Jongsma)
-  - Added write_to_png() and write_to_png_stream(), available when PNG 
-  support is available in Cairo.
-  (Jonathon Jongsma)
-* Examples: Added PNG, PDF, PS, and SVG Surface examples.
-  (Jonathon Jongsma)
-* Added API documentation generation with doxygen (Jonathon Jongsma)
- 
-0.4.0:
-
-* Add Cairo::RefPtr<> and use all reference-counted 
-  objects via it. Use the static create() methods 
-  instead of new for these classes.
-* Context:
-  - Change set_dash(void) to unset_dash().
-  - Change rotate_deg() to rotate_degrees().
-  - Change identity_matrix() to set_identity_matrix().\
-  - Change new_path() to clear_path().
-* FontFace: Remove get/set_user_data(), because it seems useless.
-
-0.3.0:
-
-* Context:
-  - Change mask_surface() to mask() and
-    set_source_surface() to set_source().
-  - Add typedef for Matrix, but a real Matrix 
-  class would be nice.
-* Pattern: Created hierarchy of classes.
-* Check for errors in constructors.
-* Exception: Rename to logic_error, and throw 
-  std::bad_alloc or std::io_base::failure instead 
-  when appropriate.
-  (Murray Cumming)
-
diff --git a/libs/cairomm/README b/libs/cairomm/README
deleted file mode 100644
index 6605a4e338..0000000000
--- a/libs/cairomm/README
+++ /dev/null
@@ -1,13 +0,0 @@
-cairomm
--------------
-
-This library provides a C++ interface to cairo.
-
-Read the file 'INSTALL' for instructions to compile and install the library.
-
-See the examples directory for example code.
-
-Use pkg-config to discover the necessary include and linker arguments. For instance,
-  pkg-config cairomm-1.0 --cflags --libs
-Ideally you would use PKG_CHECK_MODULES in your configure.ac file.
-See http://www.openismus.com for generic help with that.
diff --git a/libs/cairomm/SConscript b/libs/cairomm/SConscript
deleted file mode 100644
index 88b8b2ab06..0000000000
--- a/libs/cairomm/SConscript
+++ /dev/null
@@ -1,22 +0,0 @@
-# -*- python -*-
-
-import os
-import os.path
-import glob
-
-cairomm_files = glob.glob('cairomm/*.cc')
-
-Import('env libraries install_prefix')
-cairomm = env.Copy()
-cairomm.Merge([libraries['cairo']])
-
-libcairomm = cairomm.SharedLibrary('cairomm', cairomm_files)
-Default(libcairomm)
-
-env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2'), libcairomm))
-
-env.Alias('tarball', env.Distribute (env['DISTTREE'],
-                                     [ 'SConscript'] + 
-				     cairomm_files + 
-				     glob.glob('cairomm/*.h') 
-				     ))
diff --git a/libs/cairomm/cairomm-1.0.pc.in b/libs/cairomm/cairomm-1.0.pc.in
deleted file mode 100644
index c2832250fb..0000000000
--- a/libs/cairomm/cairomm-1.0.pc.in
+++ /dev/null
@@ -1,12 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: cairomm
-Description: C++ wrapper for cairo
-Requires: cairo
-Version: @VERSION@
-Libs: -L${libdir} -lcairomm-1.0
-Cflags: -I${includedir}/cairomm-1.0
-
diff --git a/libs/cairomm/cairomm/cairomm.h b/libs/cairomm/cairomm/cairomm.h
deleted file mode 100644
index 7f78a79a66..0000000000
--- a/libs/cairomm/cairomm/cairomm.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_H
-#define __CAIROMM_H
-
-/** @mainpage Cairomm: A C++ wrapper for the cairo graphics library
- *
- * @section License
- * Cairomm is available under the terms of the LGPL license
- *
- * @section Introduction
- * If you're just beginning to learn cairomm, a good place to start is with the
- * Cairo::Surface and Cairo::Context classes.  In general terms, you draw onto
- * a Surface using the graphics settings specified in your Context.
- *
- */
-
-#include <cairomm/context.h>
-#include <cairomm/surface.h>
-#include <cairomm/fontoptions.h>
-#include <cairomm/pattern.h>
-#include <cairomm/path.h>
-#include <cairomm/enums.h>
-
-#endif //__CAIROMM_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/context.cc b/libs/cairomm/cairomm/context.cc
deleted file mode 100644
index 5f502c5f57..0000000000
--- a/libs/cairomm/cairomm/context.cc
+++ /dev/null
@@ -1,669 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/context.h>
-#include <cairomm/private.h>
-
-/* M_PI is defined in math.h in the case of Microsoft Visual C++ */
-#if defined(_MSC_VER)
-#define _USE_MATH_DEFINES
-#include <math.h>
-#endif 
-
-namespace Cairo
-{
-
-Context::Context(const RefPtr<Surface>& target)
-: m_cobject(0)
-{
-  m_cobject = cairo_create(target->cobj());
-  check_object_status_and_throw_exception(*this);
-}
-
-RefPtr<Context> Context::create(const RefPtr<Surface>& target)
-{
-  return RefPtr<Context>(new Context(target));
-}
-
-Context::Context(cairo_t* cobject, bool has_reference)
-: m_cobject(0)
-{
-  if(has_reference)
-    m_cobject = cobject;
-  else
-    m_cobject = cairo_reference(cobject);
-}
-
-Context::~Context()
-{
-  if(m_cobject)
-    cairo_destroy(m_cobject);
-}
-
-
-void Context::reference() const
-{
- cairo_reference(m_cobject);
-}
-
-void Context::unreference() const
-{
-  cairo_destroy(m_cobject);
-}
-
-void Context::save()
-{
-  cairo_save(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::restore()
-{
-  cairo_restore(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_operator(Operator op)
-{
-  cairo_set_operator(m_cobject, static_cast<cairo_operator_t>(op));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_source(const RefPtr<const Pattern>& source)
-{
-  cairo_set_source(m_cobject, const_cast<cairo_pattern_t*>(source->cobj()));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_source_rgb(double red, double green, double blue)
-{
-  cairo_set_source_rgb(m_cobject, red, green, blue);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_source_rgba(double red, double green, double blue,
-double alpha)
-{
-  cairo_set_source_rgba(m_cobject, red, green, blue, alpha);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_source(const RefPtr<Surface>& surface, double x, double y)
-{
-  cairo_set_source_surface(m_cobject, surface->cobj(), x, y);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_tolerance(double tolerance)
-{
-  cairo_set_tolerance(m_cobject, tolerance);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_antialias(Antialias antialias)
-{
-  cairo_set_antialias(m_cobject, static_cast<cairo_antialias_t>(antialias));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_fill_rule(FillRule fill_rule)
-{
-  cairo_set_fill_rule(m_cobject, static_cast<cairo_fill_rule_t>(fill_rule));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_line_width(double width)
-{
-  cairo_set_line_width(m_cobject, width);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_line_cap(LineCap line_cap)
-{
-  cairo_set_line_cap(m_cobject, static_cast<cairo_line_cap_t>(line_cap));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_line_join(LineJoin line_join)
-{
-  cairo_set_line_join(m_cobject, static_cast<cairo_line_join_t>(line_join));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_dash(std::valarray<double>& dashes, double offset)
-{
-  cairo_set_dash(m_cobject, &dashes[0], dashes.size(), offset);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::unset_dash()
-{
-  cairo_set_dash(m_cobject, NULL, 0, 0.0);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_miter_limit(double limit)
-{
-  cairo_set_miter_limit(m_cobject, limit);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::translate(double tx, double ty)
-{
-  cairo_translate(m_cobject, tx, ty);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::scale(double sx, double sy)
-{
-  cairo_scale(m_cobject, sx, sy);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::rotate(double angle_radians)
-{
-  cairo_rotate(m_cobject, angle_radians);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::rotate_degrees(double angle_degrees)
-{
-  cairo_rotate(m_cobject, angle_degrees * M_PI/180.0);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::transform(const Matrix& matrix)
-{
-  cairo_transform(m_cobject, &matrix);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_matrix(const Matrix& matrix)
-{
-  cairo_set_matrix(m_cobject, &matrix);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_identity_matrix()
-{
-  cairo_identity_matrix(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::user_to_device(double& x, double& y)
-{
-  cairo_user_to_device(m_cobject, &x, &y);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::user_to_device_distance(double& dx, double& dy)
-{
-  cairo_user_to_device_distance(m_cobject, &dx, &dy);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::device_to_user(double& x, double& y)
-{
-  cairo_device_to_user(m_cobject, &x, &y);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::device_to_user_distance(double& dx, double& dy)
-{
-  cairo_device_to_user_distance(m_cobject, &dx, &dy);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::begin_new_path()
-{
-  cairo_new_path(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::begin_new_sub_path()
-{
-  cairo_new_sub_path(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::move_to(double x, double y)
-{
-  cairo_move_to(m_cobject, x, y);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::line_to(double x, double y)
-{
-  cairo_line_to(m_cobject, x, y);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::curve_to(double x1, double y1, double x2, double y2, double x3, double y3)
-{
-  cairo_curve_to(m_cobject, x1, y1, x2, y2, x3, y3);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::arc(double xc, double yc, double radius, double angle1, double angle2)
-{
-  cairo_arc(m_cobject, xc, yc, radius, angle1, angle2);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::arc_negative(double xc, double yc, double radius, double angle1, double angle2)
-{
-  cairo_arc_negative(m_cobject, xc, yc, radius, angle1, angle2);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::rel_move_to(double dx, double dy)
-{
-  cairo_rel_move_to(m_cobject, dx, dy);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::rel_line_to(double dx, double dy)
-{
-  cairo_rel_line_to(m_cobject, dx, dy);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::rel_curve_to(double dx1, double dy1, double dx2, double dy2, double dx3, double dy3)
-{
-  cairo_rel_curve_to(m_cobject, dx1, dy1, dx2, dy2, dx3, dy3);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::rectangle(double x, double y, double width, double height)
-{
-  cairo_rectangle(m_cobject, x, y, width, height);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::close_path()
-{
-  cairo_close_path(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::paint()
-{
-  cairo_paint(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::paint_with_alpha(double alpha)
-{
-  cairo_paint_with_alpha(m_cobject, alpha);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::mask(const RefPtr<const Pattern>& pattern)
-{
-  cairo_mask(m_cobject, const_cast<cairo_pattern_t*>(pattern->cobj()));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::mask(const RefPtr<const Surface>& surface, double surface_x, double surface_y)
-{
-  cairo_mask_surface(m_cobject, const_cast<cairo_surface_t*>(surface->cobj()), surface_x, surface_y);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::stroke()
-{
-  cairo_stroke(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::stroke_preserve()
-{
-  cairo_stroke_preserve(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::fill()
-{
-  cairo_fill(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::fill_preserve()
-{
-  cairo_fill_preserve(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::copy_page()
-{
-  cairo_copy_page(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::show_page()
-{
-  cairo_show_page(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-bool Context::in_stroke(double x, double y) const
-{
-  const bool result = cairo_in_stroke(m_cobject, x, y);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-bool Context::in_fill(double x, double y) const
-{
-  const bool result = cairo_in_fill(m_cobject, x, y);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void Context::get_stroke_extents(double& x1, double& y1, double& x2, double& y2) const
-{
-  cairo_stroke_extents(m_cobject, &x1, &y1, &x2, &y2);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::get_fill_extents(double& x1, double& y1, double& x2, double& y2) const
-{
-  cairo_fill_extents(m_cobject, &x1, &y1, &x2, &y2);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::reset_clip()
-{
-  cairo_reset_clip(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::clip()
-{
-  cairo_clip(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::clip_preserve()
-{
-  cairo_clip_preserve(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::select_font_face(const std::string& family, FontSlant slant, FontWeight weight)
-{
-  cairo_select_font_face (m_cobject, family.c_str(),
-          static_cast<cairo_font_slant_t>(slant),
-          static_cast<cairo_font_weight_t>(weight));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_font_size(double size)
-{
-  cairo_set_font_size(m_cobject, size);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_font_matrix(const Matrix& matrix)
-{
-  cairo_set_font_matrix(m_cobject, &matrix);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::get_font_matrix(Matrix& matrix) const
-{
-  cairo_get_font_matrix(m_cobject, &matrix);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_font_options(const FontOptions& options)
-{
-  cairo_set_font_options(m_cobject, options.cobj());
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::show_text(const std::string& utf8)
-{
-  cairo_show_text(m_cobject, utf8.c_str());
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::show_glyphs(const std::vector<Glyph>& glyphs)
-{
-  cairo_show_glyphs(m_cobject, const_cast<cairo_glyph_t*>(&glyphs[0]), glyphs.size());
-  check_object_status_and_throw_exception(*this);
-}
-
-RefPtr<FontFace> Context::get_font_face()
-{
-  cairo_font_face_t* cfontface = cairo_get_font_face(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<FontFace>(new FontFace(cfontface, false /* does not have reference */));
-}
-
-RefPtr<const FontFace> Context::get_font_face() const
-{
-  cairo_font_face_t* cfontface = cairo_get_font_face(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<const FontFace>(new FontFace(cfontface, false /* does not have reference */));
-}
-
-void Context::get_font_extents(FontExtents& extents) const
-{
-  cairo_font_extents(m_cobject, &extents);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::set_font_face(const RefPtr<const FontFace>& font_face)
-{
-  cairo_set_font_face(m_cobject, const_cast<cairo_font_face_t*>(font_face->cobj()));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::get_text_extents(const std::string& utf8, TextExtents& extents) const
-{
-  cairo_text_extents(m_cobject, utf8.c_str(), &extents);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::get_glyph_extents(const std::vector<Glyph>& glyphs, TextExtents& extents) const
-{
-  cairo_glyph_extents(m_cobject, const_cast<cairo_glyph_t*>(&glyphs[0]), glyphs.size(), &extents);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::text_path(const std::string& utf8)
-{
-  cairo_text_path(m_cobject, utf8.c_str());
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::glyph_path(const std::vector<Glyph>& glyphs)
-{
-  cairo_glyph_path(m_cobject, const_cast<cairo_glyph_t*>(&glyphs[0]), glyphs.size());
-  check_object_status_and_throw_exception(*this);
-}
-
-Operator Context::get_operator() const
-{
-  const Operator result = static_cast<Operator>(cairo_get_operator(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-RefPtr<Pattern> Context::get_source()
-{
-  cairo_pattern_t* pattern = cairo_get_source(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<Pattern>(new Pattern(pattern, false /* does not have reference */));
-}
-
-RefPtr<const Pattern> Context::get_source() const
-{
-  cairo_pattern_t* pattern = cairo_get_source(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<const Pattern>(new Pattern(pattern, false /* does not have reference */));
-}
-
-double Context::get_tolerance() const
-{
-  const double result = cairo_get_tolerance(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-Antialias Context::get_antialias() const
-{
-  const Antialias result = static_cast<Antialias>(cairo_get_antialias(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void Context::get_current_point(double& x, double& y) const
-{
-  cairo_get_current_point(m_cobject, &x, &y);
-  check_object_status_and_throw_exception(*this);
-}
-
-FillRule Context::get_fill_rule() const
-{
-  const FillRule result = static_cast<FillRule>(cairo_get_fill_rule(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-double Context::get_line_width() const
-{
-  const double result = cairo_get_line_width(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-LineCap Context::get_line_cap() const
-{
-  const LineCap result = static_cast<LineCap>(cairo_get_line_cap(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-LineJoin Context::get_line_join() const
-{
-  const LineJoin result = static_cast<LineJoin>(cairo_get_line_join(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-double Context::get_miter_limit() const
-{
-  const double result = cairo_get_miter_limit(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void Context::get_matrix(Matrix& matrix)
-{
-  cairo_get_matrix(m_cobject, &matrix);
-  check_object_status_and_throw_exception(*this);
-}
-
-RefPtr<Surface> Context::get_target()
-{
-  cairo_surface_t* surface = cairo_get_target(const_cast<cairo_t*>(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<Surface>(new Surface(surface, false /* does not have reference */));
-}
-
-RefPtr<const Surface> Context::get_target() const
-{
-  cairo_surface_t* surface = cairo_get_target(const_cast<cairo_t*>(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<const Surface>(new Surface(surface, false /* does not have reference */));
-}
-
-Path* Context::copy_path() const
-{
-  cairo_path_t* cresult = cairo_copy_path(const_cast<cairo_t*>(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return new Path(cresult, true /* take ownership */); //The caller must delete it.
-}
-
-Path* Context::copy_path_flat() const
-{
-  cairo_path_t* cresult = cairo_copy_path_flat(const_cast<cairo_t*>(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return new Path(cresult, true /* take ownership */); //The caller must delete it.
-}
-
-void Context::append_path(const Path& path)
-{
-  cairo_append_path(m_cobject, const_cast<cairo_path_t*>(path.cobj()));
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::push_group()
-{
-  cairo_push_group(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Context::push_group_with_content(Content content)
-{
-  cairo_push_group_with_content(m_cobject, static_cast<cairo_content_t>(content));
-  check_object_status_and_throw_exception(*this);
-}
-
-RefPtr<Pattern> Context::pop_group()
-{
-  cairo_pattern_t* pattern = cairo_pop_group(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<Pattern>(new Pattern(pattern));
-}
-
-void Context::pop_group_to_source()
-{
-  cairo_pop_group_to_source(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-RefPtr<Surface> Context::get_group_target()
-{
-  cairo_surface_t* surface = cairo_get_group_target(m_cobject);
-  // surface can be NULL if you're not between push/pop group calls
-  if (surface == NULL)
-  {
-    // FIXME: is this really the right way to handle this?
-    throw_exception(CAIRO_STATUS_NULL_POINTER);
-  }
-  return RefPtr<Surface>(new Surface(surface, false));
-}
-
-RefPtr<const Surface> Context::get_group_target() const
-{
-  cairo_surface_t* surface = cairo_get_group_target(m_cobject);
-  // surface can be NULL if you're not between push/pop group calls
-  if (surface == NULL)
-  {
-    // FIXME: is this really the right way to handle this?
-    throw_exception(CAIRO_STATUS_NULL_POINTER);
-  }
-  return RefPtr<const Surface>(new Surface(surface, false));
-}
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/context.h b/libs/cairomm/cairomm/context.h
deleted file mode 100644
index dcd3d833a6..0000000000
--- a/libs/cairomm/cairomm/context.h
+++ /dev/null
@@ -1,931 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_CONTEXT_H
-#define __CAIROMM_CONTEXT_H
-
-#include <cairomm/surface.h>
-#include <cairomm/fontface.h>
-#include <cairomm/pattern.h>
-#include <cairomm/path.h>
-#include <valarray>
-#include <vector>
-#include <cairo.h>
-
-
-namespace Cairo
-{
-
-typedef cairo_glyph_t Glyph; //A simple struct.
-typedef cairo_font_extents_t FontExtents; //A simple struct.
-typedef cairo_text_extents_t TextExtents; //A simple struct.
-typedef cairo_matrix_t Matrix; //A simple struct. //TODO: Derive and add operator[] and operator. matrix multiplication?
-
-/** Context is the main class used to draw in cairomm. 
- * In the simplest case, create a Context with its target Surface, set its
- * drawing options (line width, color, etc), create shapes with methods like
- * move_to() and line_to(), and then draw the shapes to the Surface using
- * methods such as stroke() or fill().
- *
- * Context is a reference-counted object that should be used via Cairo::RefPtr.
- */
-class Context
-{
-protected:
-  explicit Context(const RefPtr<Surface>& target);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit Context(cairo_t* cobject, bool has_reference = false);
-
-  static RefPtr<Context> create(const RefPtr<Surface>& target);
-
-  virtual ~Context();
-
-  /** Makes a copy of the current state of the Context and saves it on an
-   * internal stack of saved states. When restore() is called, it will be
-   * restored to the saved state. Multiple calls to save() and restore() can be
-   * nested; each call to restore() restores the state from the matching paired
-   * save().
-   *
-   * It isn't necessary to clear all saved states before a cairo_t is freed. 
-   * Any saved states will be freed when the Context is destroyed.
-   *
-   * @sa restore()
-   */
-  void save();
-
-  /** Restores cr to the state saved by a preceding call to save() and removes
-   * that state from the stack of saved states.
-   *
-   * @sa save()
-   */
-  void restore();
-
-  /** Sets the compositing operator to be used for all drawing operations. See
-   * Operator for details on the semantics of each available compositing
-   * operator.
-   *
-   * @param op	a compositing operator, specified as a Operator
-   */
-  void set_operator(Operator op);
-
-  /** Sets the source pattern within the Context to source. This Pattern will
-   * then be used for any subsequent drawing operation until a new source
-   * pattern is set.
-   *
-   * Note: The Pattern's transformation matrix will be locked to the user space
-   * in effect at the time of set_source(). This means that further
-   * modifications of the current transformation matrix will not affect the
-   * source pattern. 
-   *
-   * @param source	a Pattern to be used as the source for subsequent drawing
-   * operations.
-   *
-   * @sa Pattern::set_matrix()
-   * @sa set_source_rgb()
-   * @sa set_source_rgba()
-   * @sa set_source(const RefPtr<Surface>& surface, double x, double y)
-   */
-  void set_source(const RefPtr<const Pattern>& source);
-
-  /** Sets the source pattern within the Context to an opaque color. This
-   * opaque color will then be used for any subsequent drawing operation until
-   * a new source pattern is set.
-   *
-   * The color components are floating point numbers in the range 0 to 1. If
-   * the values passed in are outside that range, they will be clamped.
-   *
-   * @param red	red component of color
-   * @param green	green component of color
-   * @param blue	blue component of color
-   *
-   * @sa set_source_rgba()
-   * @sa set_source()
-   */
-  void set_source_rgb(double red, double green, double blue);
-
-  /** Sets the source pattern within the Context to a translucent color. This
-   * color will then be used for any subsequent drawing operation until a new
-   * source pattern is set.
-   *
-   * The color and alpha components are floating point numbers in the range 0
-   * to 1. If the values passed in are outside that range, they will be
-   * clamped.
-   *
-   * @param red	red component of color
-   * @param green	green component of color
-   * @param blue	blue component of color
-   * @param alpha	alpha component of color
-   *
-   * @sa set_source_rgb()
-   * @sa set_source()
-   */
-  void set_source_rgba(double red, double green, double blue, double alpha);
-
-  /** This is a convenience function for creating a pattern from a Surface and
-   * setting it as the source
-   *
-   * The x and y parameters give the user-space coordinate at which the Surface
-   * origin should appear. (The Surface origin is its upper-left corner before
-   * any transformation has been applied.) The x and y patterns are negated and
-   * then set as translation values in the pattern matrix.
-   *
-   * Other than the initial translation pattern matrix, as described above, all
-   * other pattern attributes, (such as its extend mode), are set to the
-   * default values as in Context::create(const RefPtr<Surface>& target). The
-   * resulting pattern can be queried with get_source() so that these
-   * attributes can be modified if desired, (eg. to create a repeating pattern
-   * with Pattern::set_extend()).
-   *
-   * @param surface : 	a Surface to be used to set the source pattern
-   * @param x : 	User-space X coordinate for surface origin
-   * @param y : 	User-space Y coordinate for surface origin 
-   */
-  void set_source(const RefPtr<Surface>& surface, double x, double y);
-
-  /** Sets the tolerance used when converting paths into trapezoids. Curved
-   * segments of the path will be subdivided until the maximum deviation
-   * between the original path and the polygonal approximation is less than
-   * tolerance. The default value is 0.1. A larger value will give better
-   * performance, a smaller value, better appearance. (Reducing the value from
-   * the default value of 0.1 is unlikely to improve appearance significantly.)
-   *
-   * @param tolerance	the tolerance, in device units (typically pixels)
-   */
-  void set_tolerance(double tolerance);
-
-  /** Set the antialiasing mode of the rasterizer used for drawing shapes. This
-   * value is a hint, and a particular backend may or may not support a
-   * particular value. At the current time, no backend supports
-   * CAIRO_ANTIALIAS_SUBPIXEL when drawing shapes.
-   *
-   * Note that this option does not affect text rendering, instead see
-   * FontOptions::set_antialias().
-   *
-   * @param antialias	the new antialiasing mode
-   */
-  void set_antialias(Antialias antialias);
-
-  /** Set the current fill rule within the cairo Context. The fill rule is used
-   * to determine which regions are inside or outside a complex (potentially
-   * self-intersecting) path. The current fill rule affects both fill() and
-   * clip(). See FillRule for details on the semantics of each available fill
-   * rule.
-   *
-   * @param fill_rule	a fill rule, specified as a FillRule
-   */
-  void set_fill_rule(FillRule fill_rule);
-
-  /** Sets the current line width within the cairo Context. The line width
-   * specifies the diameter of a pen that is circular in user-space.
-   *
-   * As with the other stroke parameters, the current line cap style is
-   * examined by stroke(), stroke_extents(), and stroke_to_path(), but does not
-   * have any effect during path construction.
-   *
-   * @param width	a line width, as a user-space value
-   */
-  void set_line_width(double width);
-  
-  /** Sets the current line cap style within the cairo Context. See
-   * LineCap for details about how the available line cap styles are drawn.
-   *
-   * As with the other stroke parameters, the current line cap style is
-   * examined by stroke(), stroke_extents(), and stroke_to_path(), but does not
-   * have any effect during path construction.
-   *
-   * @param line_cap	a line cap style, as a LineCap
-   */
-  void set_line_cap(LineCap line_cap);
-
-  /** Sets the current line join style within the cairo Context. See LineJoin
-   * for details about how the available line join styles are drawn.
-   *
-   * As with the other stroke parameters, the current line join style is
-   * examined by stroke(), stroke_extents(), and stroke_to_path(), but does not
-   * have any effect during path construction.
-   *
-   * @param line_join	a line joint style, as a LineJoin
-   */
-  void set_line_join(LineJoin line_join);
-
-  /** Sets the dash pattern to be used by stroke(). A dash pattern is specified
-   * by dashes, an array of positive values. Each value provides the user-space
-   * length of altenate "on" and "off" portions of the stroke. The offset
-   * specifies an offset into the pattern at which the stroke begins.
-   *
-   * If dashes is empty dashing is disabled.  If the size of dashes is 1, a
-   * symmetric pattern is assumed with alternating on and off portions of the
-   * size specified by the single value in dashes.
-   *
-   * It is invalid for any value in dashes to be negative, or for all values to
-   * be 0.  If this is the case, an exception will be thrown
-   *
-   * @param dashes	an array specifying alternate lengths of on and off portions
-   * @param offset	an offset into the dash pattern at which the stroke should start
-   *
-   * @exception
-   */
-  void set_dash(std::valarray<double>& dashes, double offset);
-
-  /** This function disables a dash pattern that was set with set_dash()
-   */
-  void unset_dash();
-  void set_miter_limit(double limit);
-
-  /** Modifies the current transformation matrix (CTM) by translating the
-   * user-space origin by (tx, ty). This offset is interpreted as a user-space
-   * coordinate according to the CTM in place before the new call to
-   * cairo_translate. In other words, the translation of the user-space origin
-   * takes place after any existing transformation.
-   *
-   * @param tx	amount to translate in the X direction
-   * @param ty	amount to translate in the Y direction 
-   */
-  void translate(double tx, double ty);
-
-  /** Modifies the current transformation matrix (CTM) by scaling the X and Y
-   * user-space axes by sx and sy respectively. The scaling of the axes takes
-   * place after any existing transformation of user space.
-   *
-   * @param sx	scale factor for the X dimension
-   * @param sy	scale factor for the Y dimension
-   */
-  void scale(double sx, double sy);
-
-  /** Modifies the current transformation matrix (CTM) by rotating the
-   * user-space axes by angle radians. The rotation of the axes takes places
-   * after any existing transformation of user space. The rotation direction
-   * for positive angles is from the positive X axis toward the positive Y
-   * axis.
-   *
-   * @param angle	angle (in radians) by which the user-space axes will be
-   * rotated
-   */
-  void rotate(double angle_radians);
-
-  /** A convenience wrapper around rotate() that accepts angles in degrees
-   *
-   * @param angle_degrees angle (in degrees) by which the user-space axes
-   * should be rotated
-   */
-  void rotate_degrees(double angle_degres);
-
-  /** Modifies the current transformation matrix (CTM) by applying matrix as an
-   * additional transformation. The new transformation of user space takes
-   * place after any existing transformation.
-   *
-   * @param matrix	a transformation to be applied to the user-space axes
-   */
-  void transform(const Matrix& matrix);
-
-  /** Modifies the current transformation matrix (CTM) by setting it equal to
-   * matrix.
-   *
-   * @param matrix	a transformation matrix from user space to device space
-   */
-  void set_matrix(const Matrix& matrix);
-
-  /** Resets the current transformation matrix (CTM) by setting it equal to the
-   * identity matrix. That is, the user-space and device-space axes will be
-   * aligned and one user-space unit will transform to one device-space unit.
-   */
-  void set_identity_matrix();
-
-  /** Transform a coordinate from user space to device space by multiplying the
-   * given point by the current transformation matrix (CTM).
-   *
-   * @param x	X value of coordinate (in/out parameter)
-   * @param y	Y value of coordinate (in/out parameter)
-   */
-  void user_to_device(double& x, double& y);
-
-  /** Transform a distance vector from user space to device space. This
-   * function is similar to user_to_device() except that the translation
-   * components of the CTM will be ignored when transforming (dx,dy).
-   *
-   * @param dx	X component of a distance vector (in/out parameter)
-   * @param dy	Y component of a distance vector (in/out parameter)
-   */
-  void user_to_device_distance(double& dx, double& dy);
-
-  /** Transform a coordinate from device space to user space by multiplying the
-   * given point by the inverse of the current transformation matrix (CTM).
-   *
-   * @param x	X value of coordinate (in/out parameter)
-   * @param y	Y value of coordinate (in/out parameter)
-   */
-  void device_to_user(double& x, double& y);
-
-  /** Transform a distance vector from device space to user space. This
-   * function is similar to device_to_user() except that the translation
-   * components of the inverse CTM will be ignored when transforming (dx,dy).
-   *
-   * @param dx	X component of a distance vector (in/out parameter)
-   * @param dy	Y component of a distance vector (in/out parameter)
-   */
-  void device_to_user_distance(double& dx, double& dy);
-
-  /** Clears the current path. After this call there will be no current point.
-   */
-  void begin_new_path();
-
-  /** Begin a new subpath. Note that the existing path is not affected. After
-   * this call there will be no current point.
-   *
-   * In many cases, this call is not needed since new subpaths are frequently
-   * started with move_to().
-   *
-   * A call to begin_new_sub_path() is particularly useful when beginning a new
-   * subpath with one of the arc() calls. This makes things easier as it is no
-   * longer necessary to manually compute the arc's initial coordinates for a
-   * call to move_to().
-   */
-  void begin_new_sub_path();
-
-  /** If the current subpath is not empty, begin a new subpath. After this call
-   * the current point will be (x, y).
-   *
-   * @param x	the X coordinate of the new position
-   * @param y	the Y coordinate of the new position
-   */
-  void move_to(double x, double y);
-
-  /** Adds a line to the path from the current point to position (x, y) in
-   * user-space coordinates. After this call the current point will be (x, y).
-   *
-   * @param x	the X coordinate of the end of the new line
-   * @param y	the Y coordinate of the end of the new line
-   */
-  void line_to(double x, double y);
-
-  /** Adds a cubic Bezier spline to the path from the current point to position
-   * (x3, y3) in user-space coordinates, using (x1, y1) and (x2, y2) as the
-   * control points. After this call the current point will be (x3, y3).
-   *
-   * @param x1	the X coordinate of the first control point
-   * @param y1	the Y coordinate of the first control point
-   * @param x2	the X coordinate of the second control point
-   * @param y2	the Y coordinate of the second control point
-   * @param x3	the X coordinate of the end of the curve
-   * @param y3	the Y coordinate of the end of the curve
-   */
-  void curve_to(double x1, double y1, double x2, double y2, double x3, double y3);
-
-  /** Adds a circular arc of the given radius to the current path. The arc is
-   * centered at (xc, yc), begins at angle1 and proceeds in the direction of
-   * increasing angles to end at angle2. If angle2 is less than angle1 it will
-   * be progressively increased by 2*M_PI until it is greater than angle1.
-   *
-   * If there is a current point, an initial line segment will be added to the
-   * path to connect the current point to the beginning of the arc.
-   *
-   * Angles are measured in radians. An angle of 0 is in the direction of the
-   * positive X axis (in user-space). An angle of M_PI radians (90 degrees) is
-   * in the direction of the positive Y axis (in user-space). Angles increase
-   * in the direction from the positive X axis toward the positive Y axis. So
-   * with the default transformation matrix, angles increase in a clockwise
-   * direction.
-   *
-   * (To convert from degrees to radians, use degrees * (M_PI / 180.).)
-   *
-   * This function gives the arc in the direction of increasing angles; see
-   * arc_negative() to get the arc in the direction of decreasing angles.
-   *
-   * The arc is circular in user-space. To achieve an elliptical arc, you can
-   * scale the current transformation matrix by different amounts in the X and
-   * Y directions. For example, to draw an ellipse in the box given by x, y,
-   * width, height:
-   *
-   * @code
-   * context->save();
-   * context->translate(x, y);
-   * context->scale(width / 2.0, height / 2.0);
-   * context->arc(0.0, 0.0, 1.0, 0.0, 2 * M_PI);
-   * context->restore();
-   * @endcode
-   *
-   * @param xc	X position of the center of the arc
-   * @param yc	Y position of the center of the arc
-   * @param radius	the radius of the arc
-   * @param angle1	the start angle, in radians
-   * @param angle2	the end angle, in radians
-   */
-  void arc(double xc, double yc, double radius, double angle1, double angle2);
-
-  /** Adds a circular arc of the given radius to the current path. The arc is
-   * centered at (xc, yc), begins at angle1 and proceeds in the direction of
-   * decreasing angles to end at angle2. If angle2 is greater than angle1 it
-   * will be progressively decreased by 2*M_PI until it is greater than angle1.
-   *
-   * See arc() for more details. This function differs only in the direction of
-   * the arc between the two angles.
-   *
-   * @param xc	X position of the center of the arc
-   * @param yc	Y position of the center of the arc
-   * @param radius	the radius of the arc
-   * @param angle1	the start angle, in radians
-   * @param angle2	the end angle, in radians
-   */
-  void arc_negative(double xc, double yc, double radius, double angle1, double angle2);
-
-  /** If the current subpath is not empty, begin a new subpath. After this call
-   * the current point will offset by (x, y).
-   *
-   * Given a current point of (x, y),
-   * @code
-   * rel_move_to(dx, dy)
-   * @endcode
-   * is logically equivalent to
-   * @code
-   * move_to(x + dx, y + dy)
-   * @endcode
-   *
-   * @param dx	the X offset
-   * @param dy	the Y offset
-   */
-  void rel_move_to(double dx, double dy);
-
-  /** Relative-coordinate version of line_to(). Adds a line to the path from
-   * the current point to a point that is offset from the current point by (dx,
-   * dy) in user space. After this call the current point will be offset by
-   * (dx, dy).
-   *
-   * Given a current point of (x, y),
-   * @code
-   * rel_line_to(dx, dy)
-   * @endcode
-   * is logically equivalent to
-   * @code
-   * line_to(x + dx, y + dy).
-   * @endcode
-   *
-   * @param dx	the X offset to the end of the new line
-   * @param dy	the Y offset to the end of the new line
-   */
-  void rel_line_to(double dx, double dy);
-
-  /** Relative-coordinate version of curve_to(). All offsets are relative to
-   * the current point. Adds a cubic Bezier spline to the path from the current
-   * point to a point offset from the current point by (dx3, dy3), using points
-   * offset by (dx1, dy1) and (dx2, dy2) as the control points.  After this
-   * call the current point will be offset by (dx3, dy3).
-   *
-   * Given a current point of (x, y),
-   * @code
-   * rel_curve_to(dx1, dy1, dx2, dy2, dx3, dy3)
-   * @endcode
-   * is logically equivalent to
-   * @code
-   * curve_to(x + dx1, y + dy1, x + dx2, y + dy2, x + dx3, y + dy3).
-   * @endcode
-   *
-   * @param dx1	the X offset to the first control point
-   * @param dy1	the Y offset to the first control point
-   * @param dx2	the X offset to the second control point
-   * @param dy2	the Y offset to the second control point
-   * @param dx3	the X offset to the end of the curve
-   * @param dy3	the Y offset to the end of the curve
-   */
-  void rel_curve_to(double dx1, double dy1, double dx2, double dy2, double dx3, double dy3);
-
-  /** Adds a closed-subpath rectangle of the given size to the current path at
-   * position (x, y) in user-space coordinates.
-   *
-   * This function is logically equivalent to:
-   *
-   * @code
-   * context->move_to(x, y);
-   * context->rel_line_to(width, 0);
-   * context->rel_line_to(0, height);
-   * context->rel_line_to(-width, 0);
-   * context->close_path();
-   * @endcode
-   *
-   * @param x	the X coordinate of the top left corner of the rectangle
-   * @param y	the Y coordinate to the top left corner of the rectangle
-   * @param width	the width of the rectangle
-   * @param height	the height of the rectangle
-   */
-  void rectangle(double x, double y, double width, double height);
-
-  /** Adds a line segment to the path from the current point to the beginning
-   * of the current subpath, (the most recent point passed to move_to()), and
-   * closes this subpath.
-   *
-   * The behavior of close_path() is distinct from simply calling line_to()
-   * with the equivalent coordinate in the case of stroking.  When a closed
-   * subpath is stroked, there are no caps on the ends of the subpath. Instead,
-   * there is a line join connecting the final and initial segments of the
-   * subpath.
-   */
-  void close_path();
-
-  /** A drawing operator that paints the current source everywhere within the
-   * current clip region.
-   */
-  void paint();
-
-  /** A drawing operator that paints the current source everywhere within the
-   * current clip region using a mask of constant alpha value alpha. The effect
-   * is similar to paint(), but the drawing is faded out using the alpha
-   * value.
-   *
-   * @param alpha	an alpha value, between 0 (transparent) and 1 (opaque)
-   */
-  void paint_with_alpha(double alpha);
-
-  /** A drawing operator that paints the current source using the alpha channel
-   * of pattern as a mask. (Opaque areas of mask are painted with the source,
-   * transparent areas are not painted.)
-   *
-   * @param pattern a Pattern
-   */
-  void mask(const RefPtr<const Pattern>& pattern);
-
-  /** A drawing operator that paints the current source using the alpha channel
-   * of surface as a mask. (Opaque areas of surface are painted with the
-   * source, transparent areas are not painted.)
-   *
-   * @param surface	a Surface
-   * @param surface_x	X coordinate at which to place the origin of surface
-   * @param surface_y	Y coordinate at which to place the origin of surface
-   */
-  void mask(const RefPtr<const Surface>& surface, double surface_x, double surface_y);
-
-  /** A drawing operator that strokes the current Path according to the current
-   * line width, line join, line cap, and dash settings. After stroke(),
-   * the current Path will be cleared from the cairo Context.
-   *
-   * @sa set_line_width()
-   * @sa set_line_join()
-   * @sa set_line_cap()
-   * @sa set_dash()
-   * @sa stroke_preserve().
-   */
-  void stroke();
-
-  /** A drawing operator that strokes the current Path according to the current
-   * line width, line join, line cap, and dash settings. Unlike stroke(),
-   * stroke_preserve() preserves the Path within the cairo Context.
-   *
-   * @sa set_line_width()
-   * @sa set_line_join()
-   * @sa set_line_cap()
-   * @sa set_dash()
-   * @sa stroke_preserve().
-   */
-  void stroke_preserve();
-
-  /** A drawing operator that fills the current path according to the current
-   * fill rule, (each sub-path is implicitly closed before being filled). After
-   * fill(), the current path will be cleared from the cairo context. 
-   *
-   * @sa set_fill_rule() 
-   * @sa fill_preserve()
-   */
-  void fill();
-
-  /** A drawing operator that fills the current path according to the current
-   * fill rule, (each sub-path is implicitly closed before being filled).
-   * Unlike fill(), fill_preserve() preserves the path within the
-   * cairo Context.
-   *
-   * @sa set_fill_rule() 
-   * @sa fill().
-   */
-  void fill_preserve();
-  void copy_page();
-  void show_page();
-  bool in_stroke(double x, double y) const;
-  bool in_fill(double x, double y) const;
-  void get_stroke_extents(double& x1, double& y1, double& x2, double& y2) const;
-  void get_fill_extents(double& x1, double& y1, double& x2, double& y2) const;
-
-  /** Reset the current clip region to its original, unrestricted state. That
-   * is, set the clip region to an infinitely large shape containing the target
-   * surface. Equivalently, if infinity is too hard to grasp, one can imagine
-   * the clip region being reset to the exact bounds of the target surface.
-   *
-   * Note that code meant to be reusable should not call reset_clip() as it
-   * will cause results unexpected by higher-level code which calls clip().
-   * Consider using save() and restore() around clip() as a more robust means
-   * of temporarily restricting the clip region.
-   */
-  void reset_clip();
-
-  /** Establishes a new clip region by intersecting the current clip region
-   * with the current Path as it would be filled by fill() and according to the
-   * current fill rule.
-   *
-   * After clip(), the current path will be cleared from the cairo Context.
-   *
-   * The current clip region affects all drawing operations by effectively
-   * masking out any changes to the surface that are outside the current clip
-   * region.
-   *
-   * Calling clip() can only make the clip region smaller, never larger.  But
-   * the current clip is part of the graphics state, so a temporary restriction
-   * of the clip region can be achieved by calling cairo_clip() within a
-   * save()/restore() pair. The only other means of increasing the size of the
-   * clip region is reset_clip().
-   *
-   * @sa set_fill_rule()
-   */
-  void clip();
-
-  /** Establishes a new clip region by intersecting the current clip region
-   * with the current path as it would be filled by fill() and according to the
-   * current fill rule.
-   *
-   * Unlike clip(), cairo_clip_preserve preserves the path within the cairo
-   * Context. 
-   *
-   * @sa clip()
-   * @sa set_fill_rule()
-   */
-  void clip_preserve();
-  void select_font_face(const std::string& family, FontSlant slant, FontWeight weight);
-  void set_font_size(double size);
-  void set_font_matrix(const Matrix& matrix);
-  void get_font_matrix(Matrix& matrix) const;
-  void set_font_options(const FontOptions& options);
-  void show_text(const std::string& utf8);
-  void show_glyphs(const std::vector<Glyph>& glyphs);
-  RefPtr<FontFace> get_font_face();
-  RefPtr<const FontFace> get_font_face() const;
-  void get_font_extents(FontExtents& extents) const;
-  void set_font_face(const RefPtr<const FontFace>& font_face);
-  void get_text_extents(const std::string& utf8, TextExtents& extents) const;
-  void get_glyph_extents(const std::vector<Glyph>& glyphs, TextExtents& extents) const;
-  void text_path(const std::string& utf8);
-  void glyph_path(const std::vector<Glyph>& glyphs);
-
-  /** Gets the current compositing operator for a cairo Context
-   */
-  Operator get_operator() const;
-
-  /** Gets the current source pattern for the Context
-   */
-  RefPtr<Pattern> get_source();
-  RefPtr<const Pattern> get_source() const;
-
-  /** Gets the current tolerance value, as set by set_tolerance()
-   */
-  double get_tolerance() const;
-
-  /** Gets the current shape antialiasing mode, as set by set_antialias()
-   */
-  Antialias get_antialias() const;
-
-  /** Gets the current point of the current path, which is conceptually the
-   * final point reached by the path so far.
-   *
-   * The current point is returned in the user-space coordinate system. If
-   * there is no defined current point then x and y will both be set to 0.0.
-   * 
-   * Most path construction functions alter the current point. See the
-   * following for details on how they affect the current point: clear_path(),
-   * move_to(), line_to(), curve_to(), arc(), rel_move_to(), rel_line_to(),
-   * rel_curve_to(), arc(), and text_path()
-   *
-   * @param x	return value for X coordinate of the current point
-   * @param y	return value for Y coordinate of the current point
-   */
-  void get_current_point (double& x, double& y) const;
-
-  /** Gets the current fill rule, as set by set_fill_rule().
-   */
-  FillRule get_fill_rule() const;
-
-  /** Gets the current line width, as set by set_line_width()
-   */
-  double get_line_width() const;
-
-  /** Gets the current line cap style, as set by set_line_cap()
-   */
-  LineCap get_line_cap() const;
-
-  /** Gets the current line join style, as set by set_line_join()
-   */
-  LineJoin get_line_join() const;
-
-  /** Gets the current miter limit, as set by set_miter_limit()
-   */
-  double get_miter_limit() const;
-
-  /** Stores the current transformation matrix (CTM) into matrix.
-   *
-   * @param matrix	return value for the matrix
-   */
-  void get_matrix(Matrix& matrix);
-
-  /** Gets the target surface associated with this Context.
-   *
-   * @exception
-   */
-  RefPtr<Surface> get_target();
-
-  /** Gets the target surface associated with this Context.
-   *
-   * @exception
-   */
-  RefPtr<const Surface> get_target() const;
-  
-  //TODO: Copy or reference-count a Path somethow instead of asking the caller to delete it?
-  /** Creates a copy of the current path and returns it to the user.
-   *
-   * @todo See cairo_path_data_t for hints on how to iterate over the returned
-   * data structure.
-   *
-   * @note The caller owns the Path object returned from this function.  The
-   * Path object must be freed when you are finished with it.
-   */
-  Path* copy_path() const;
-
-  /** Gets a flattened copy of the current path and returns it to the user
-   *
-   * @todo See cairo_path_data_t for hints on how to iterate over the returned
-   * data structure.
-   *
-   * This function is like copy_path() except that any curves in the path will
-   * be approximated with piecewise-linear approximations, (accurate to within
-   * the current tolerance value). That is, the result is guaranteed to not have
-   * any elements of type CAIRO_PATH_CURVE_TO which will instead be
-   * replaced by a series of CAIRO_PATH_LINE_TO elements. 
-   *
-   * @note The caller owns the Path object returned from this function.  The
-   * Path object must be freed when you are finished with it.
-   */
-  Path* copy_path_flat() const;
-
-  /** Append the path onto the current path. The path may be either the return
-   * value from one of copy_path() or copy_path_flat() or it may be constructed
-   * manually. 
-   *
-   * @param path	path to be appended
-   */
-  void append_path(const Path& path);
-
-  /** Temporarily redirects drawing to an intermediate surface known as a group.
-   * The redirection lasts until the group is completed by a call to pop_group()
-   * or pop_group_to_source(). These calls provide the result of any drawing to
-   * the group as a pattern, (either as an explicit object, or set as the source
-   * pattern).
-   *
-   * This group functionality can be convenient for performing intermediate
-   * compositing. One common use of a group is to render objects as opaque
-   * within the group, (so that they occlude each other), and then blend the
-   * result with translucence onto the destination.
-   *
-   * Groups can be nested arbitrarily deep by making balanced calls to
-   * push_group()/pop_group(). Each call pushes/pops the new target group
-   * onto/from a stack.
-   *
-   * The push_group() function calls save() so that any changes to the graphics
-   * state will not be visible outside the group, (the pop_group functions call
-   * restore()).
-   *
-   * By default the intermediate group will have a content type of
-   * CONTENT_COLOR_ALPHA. Other content types can be chosen for the group by
-   * using push_group_with_content() instead.
-   *
-   * As an example, here is how one might fill and stroke a path with
-   * translucence, but without any portion of the fill being visible under the
-   * stroke:
-   *
-   * @code
-   * cr->push_group();
-   * cr->set_source(fill_pattern);
-   * cr->fill_preserve();
-   * cr->set_source(stroke_pattern);
-   * cr->stroke();
-   * cr->pop_group_to_source();
-   * cr->paint_with_alpha(alpha);
-   * @endcode
-   */
-  void push_group();
-
-  /**
-   * Temporarily redirects drawing to an intermediate surface known as a
-   * group. The redirection lasts until the group is completed by a call
-   * to pop_group() or pop_group_to_source(). These calls provide the result of
-   * any drawing to the group as a pattern, (either as an explicit object, or set
-   * as the source pattern).
-   *
-   * The group will have a content type of @content. The ability to control this
-   * content type is the only distinction between this function and push_group()
-   * which you should see for a more detailed description of group rendering.
-   *
-   * @param content: indicates the type of group that will be created
-   */
-  void push_group_with_content(Content content);
-
-  /**
-   * Terminates the redirection begun by a call to push_group() or
-   * push_group_with_content() and returns a new pattern containing the results
-   * of all drawing operations performed to the group.
-   *
-   * The pop_group() function calls restore(), (balancing a call to save() by
-   * the push_group function), so that any changes to the graphics state will
-   * not be visible outside the group.
-   *
-   * @return a (surface) pattern containing the results of all drawing
-   * operations performed to the group.
-   **/
-  RefPtr<Pattern> pop_group();
-
-  /**
-   * Terminates the redirection begun by a call to push_group() or
-   * push_group_with_content() and installs the resulting pattern as the source
-   * pattern in the given cairo Context.
-   *
-   * The behavior of this function is equivalent to the sequence of operations:
-   *
-   * @code
-   * RefPtr<Pattern> group = cr->pop_group();
-   * cr->set_source(group);
-   * @endcode
-   *
-   * but is more convenient as their is no need for a variable to store
-   * the short-lived pointer to the pattern.
-   *
-   * The pop_group() function calls restore(), (balancing a call to save() by
-   * the push_group function), so that any changes to the graphics state will
-   * not be visible outside the group.
-   **/
-  void pop_group_to_source();
-
-  /**
-   * Gets the target surface for the current group as started by the most recent
-   * call to push_group() or push_group_with_content().
-   *
-   * This function will return NULL if called "outside" of any group rendering
-   * blocks, (that is, after the last balancing call to pop_group() or
-   * pop_group_to_source()).
-   *
-   * @exception
-   *
-   **/
-  RefPtr<Surface> get_group_target();
-
-  /**
-   * Same as the non-const version but returns a reference to a const Surface
-   */
-  RefPtr<const Surface> get_group_target() const;
-
-  /** The base cairo C type that is wrapped by Cairo::Context
-   */
-  typedef cairo_t cobject;
-
-  /** Gets a pointer to the base C type that is wrapped by the Context
-   */
-  inline cobject* cobj() { return m_cobject; }
-
-  /** Gets a pointer to the base C type that is wrapped by the Context
-   */
-  inline const cobject* cobj() const { return m_cobject; }
- 
-  #ifndef DOXYGEN_IGNORE_THIS
-  ///For use only by the cairomm implementation.
-  inline ErrorStatus get_status() const
-  { return cairo_status(const_cast<cairo_t*>(cobj())); }
-
-  void reference() const;
-  void unreference() const;
-  #endif //DOXYGEN_IGNORE_THIS
-
-protected:
-
- 
-  cobject* m_cobject;
-};
-
-} // namespace Cairo
-
-#endif //__CAIROMM_CONTEXT_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/enums.h b/libs/cairomm/cairomm/enums.h
deleted file mode 100644
index e2023ed265..0000000000
--- a/libs/cairomm/cairomm/enums.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_ENUMS_H
-#define __CAIROMM_ENUMS_H
-
-#include <cairo.h>
-
-namespace Cairo
-{
-
-#ifndef DOXYGEN_IGNORE_THIS
-//This is only used internally, but it must be in a public header because we inline some methods.
-typedef cairo_status_t ErrorStatus;
-#endif //DOXYGEN_IGNORE_THIS
-
-
-typedef enum
-{
-    OPERATOR_CLEAR = CAIRO_OPERATOR_CLEAR,
-
-    OPERATOR_SOURCE = CAIRO_OPERATOR_SOURCE,
-    OPERATOR_OVER = CAIRO_OPERATOR_OVER,
-    OPERATOR_IN = CAIRO_OPERATOR_IN,
-    OPERATOR_OUT = CAIRO_OPERATOR_OUT,
-    OPERATOR_ATOP = CAIRO_OPERATOR_ATOP,
-
-    OPERATOR_DEST = CAIRO_OPERATOR_DEST,
-    OPERATOR_DEST_OVER = CAIRO_OPERATOR_DEST_OVER,
-    OPERATOR_DEST_IN = CAIRO_OPERATOR_DEST_IN,
-    OPERATOR_DEST_OUT = CAIRO_OPERATOR_DEST_OUT,
-    OPERATOR_DEST_ATOP = CAIRO_OPERATOR_DEST_ATOP,
-
-    OPERATOR_XOR = CAIRO_OPERATOR_XOR,
-    OPERATOR_ADD = CAIRO_OPERATOR_ADD,
-    OPERATOR_SATURATE = CAIRO_OPERATOR_SATURATE
-} Operator;
-
-
-typedef enum
-{
-    ANTIALIAS_DEFAULT = CAIRO_ANTIALIAS_DEFAULT,
-    ANTIALIAS_NONE = CAIRO_ANTIALIAS_NONE,
-    ANTIALIAS_GRAY = CAIRO_ANTIALIAS_GRAY,
-    ANTIALIAS_SUBPIXEL = CAIRO_ANTIALIAS_SUBPIXEL
-} Antialias;
-
-typedef enum
-{
-    FILL_RULE_WINDING = CAIRO_FILL_RULE_WINDING,
-    FILL_RULE_EVEN_ODD = CAIRO_FILL_RULE_EVEN_ODD
-} FillRule;
-
-
-typedef enum
-{
-    LINE_CAP_BUTT = CAIRO_LINE_CAP_BUTT,
-    LINE_CAP_ROUND = CAIRO_LINE_CAP_ROUND,
-    LINE_CAP_SQUARE = CAIRO_LINE_CAP_SQUARE
-} LineCap;
-
-
-typedef enum
-{
-    LINE_JOIN_MITER = CAIRO_LINE_JOIN_MITER,
-    LINE_JOIN_ROUND = CAIRO_LINE_JOIN_ROUND,
-    LINE_JOIN_BEVEL = CAIRO_LINE_JOIN_BEVEL
-} LineJoin;
-
-
-typedef enum
-{
-  FONT_SLANT_NORMAL = CAIRO_FONT_SLANT_NORMAL,
-  FONT_SLANT_ITALIC = CAIRO_FONT_SLANT_ITALIC,
-  FONT_SLANT_OBLIQUE = CAIRO_FONT_SLANT_OBLIQUE
-} FontSlant;
-
-typedef enum
-{
-  FONT_WEIGHT_NORMAL = CAIRO_FONT_WEIGHT_NORMAL,
-  FONT_WEIGHT_BOLD = CAIRO_FONT_WEIGHT_BOLD
-} FontWeight;
-
-
-typedef enum
-{
-    CONTENT_COLOR = CAIRO_CONTENT_COLOR,
-    CONTENT_ALPHA = CAIRO_CONTENT_ALPHA,
-    CONTENT_COLOR_ALPHA = CAIRO_CONTENT_COLOR_ALPHA
-} Content;
-
-
-typedef enum
-{
-    FORMAT_ARGB32 = CAIRO_FORMAT_ARGB32,
-    FORMAT_RGB24 = CAIRO_FORMAT_RGB24,
-    FORMAT_A8 = CAIRO_FORMAT_A8,
-    FORMAT_A1 = CAIRO_FORMAT_A1,
-    FORMAT_RGB16_565 = CAIRO_FORMAT_RGB16_565
-} Format;
-
-
-typedef enum
-{
-    EXTEND_NONE = CAIRO_EXTEND_NONE,
-    EXTEND_REPEAT = CAIRO_EXTEND_REPEAT,
-    EXTEND_REFLECT = CAIRO_EXTEND_REFLECT,
-#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1,1,1)
-    EXTEND_PAD = CAIRO_EXTEND_PAD
-#endif /* CAIRO_VERSION > CAIRO_VERSION_ENCODE(1,1,1) */
-} Extend;
-
-
-typedef enum
-{
-    FILTER_FAST = CAIRO_FILTER_FAST,
-    FILTER_GOOD = CAIRO_FILTER_GOOD,
-    FILTER_BEST = CAIRO_FILTER_BEST,
-    FILTER_NEAREST = CAIRO_FILTER_NEAREST,
-    FILTER_BILINEAR = CAIRO_FILTER_BILINEAR,
-    FILTER_GAUSSIAN = CAIRO_FILTER_GAUSSIAN
-} Filter;
-
-typedef enum
-{
-    SUBPIXEL_ORDER_DEFAULT = CAIRO_SUBPIXEL_ORDER_DEFAULT,
-    SUBPIXEL_ORDER_RGB = CAIRO_SUBPIXEL_ORDER_RGB,
-    SUBPIXEL_ORDER_BGR = CAIRO_SUBPIXEL_ORDER_BGR,
-    SUBPIXEL_ORDER_VRGB = CAIRO_SUBPIXEL_ORDER_VRGB,
-    SUBPIXEL_ORDER_VBGR = CAIRO_SUBPIXEL_ORDER_VBGR
-} SubpixelOrder;
-
-
-typedef enum
-{
-    HINT_STYLE_DEFAULT = CAIRO_HINT_STYLE_DEFAULT,
-    HINT_STYLE_NONE = CAIRO_HINT_STYLE_NONE,
-    HINT_STYLE_SLIGHT = CAIRO_HINT_STYLE_SLIGHT,
-    HINT_STYLE_MEDIUM = CAIRO_HINT_STYLE_MEDIUM,
-    HINT_STYLE_FULL = CAIRO_HINT_STYLE_FULL
-} HintStyle;
-
-
-typedef enum
-{
-    HINT_METRICS_DEFAULT = CAIRO_HINT_METRICS_DEFAULT,
-    HINT_METRICS_OFF = CAIRO_HINT_METRICS_OFF,
-    HINT_METRICS_ON = CAIRO_HINT_METRICS_ON
-} HintMetrics;
-
-typedef enum
-{
-    SURFACE_TYPE_IMAGE = CAIRO_SURFACE_TYPE_IMAGE,
-    SURFACE_TYPE_PDF = CAIRO_SURFACE_TYPE_PDF,
-    SURFACE_TYPE_PS = CAIRO_SURFACE_TYPE_PS,
-    SURFACE_TYPE_XLIB = CAIRO_SURFACE_TYPE_XLIB,
-    SURFACE_TYPE_XCB = CAIRO_SURFACE_TYPE_XCB,
-    SURFACE_TYPE_GLITZ = CAIRO_SURFACE_TYPE_GLITZ,
-    SURFACE_TYPE_QUARTZ = CAIRO_SURFACE_TYPE_QUARTZ,
-    SURFACE_TYPE_WIN32 = CAIRO_SURFACE_TYPE_WIN32,
-    SURFACE_TYPE_BEOS = CAIRO_SURFACE_TYPE_BEOS,
-    SURFACE_TYPE_DIRECTFB = CAIRO_SURFACE_TYPE_DIRECTFB,
-    SURFACE_TYPE_SVG = CAIRO_SURFACE_TYPE_SVG
-} SurfaceType;
-
-typedef enum
-{
-    PATTERN_TYPE_SOLID = CAIRO_PATTERN_TYPE_SOLID,
-    PATTERN_TYPE_SURFACE = CAIRO_PATTERN_TYPE_SURFACE,
-    PATTERN_TYPE_LINEAR = CAIRO_PATTERN_TYPE_LINEAR,
-    PATTERN_TYPE_RADIAL = CAIRO_PATTERN_TYPE_RADIAL
-} PatternType;
-
-typedef enum
-{
-    FONT_TYPE_TOY = CAIRO_FONT_TYPE_TOY,
-    FONT_TYPE_FT = CAIRO_FONT_TYPE_FT,
-    FONT_TYPE_WIN32 = CAIRO_FONT_TYPE_WIN32,
-    FONT_TYPE_ATSUI = CAIRO_FONT_TYPE_ATSUI
-} FontType;
-
-} // namespace Cairo
-
-#endif //__CAIROMM_ENUMS_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/exception.cc b/libs/cairomm/cairomm/exception.cc
deleted file mode 100644
index 0144f08a0b..0000000000
--- a/libs/cairomm/cairomm/exception.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/exception.h>
-
-namespace Cairo
-{
-
-inline static const char* string_or_empty(const char* text)
-{
-  return (text ? text : "");
-}
-
-//TODO: Is it wise to assume that the string is ASCII, as expected by std::logic_error?
-logic_error::logic_error(ErrorStatus status)
-: std::logic_error( string_or_empty(cairo_status_to_string((cairo_status_t)m_status)) ),
-  m_status(status)
-{
-}
-
-logic_error::~logic_error() throw()
-{}
-
-/*
-const char* logic_error::what() const throw()
-{
-  //Hopefully this is a const char* to a static string.
-  return cairo_status_to_string((cairo_status_t)m_status);
-}
-*/
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/exception.h b/libs/cairomm/cairomm/exception.h
deleted file mode 100644
index 6205a84c16..0000000000
--- a/libs/cairomm/cairomm/exception.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIRO_EXCEPTION_H
-#define __CAIRO_EXCEPTION_H
-
-#include <cairomm/enums.h>
-#include <stdexcept>
-
-namespace Cairo
-{
-
-/** 
- */
-class logic_error: public std::logic_error
-{
-public:
-  explicit logic_error(ErrorStatus status);
-  virtual ~logic_error() throw();
-
-  //virtual const char* what() const throw();
-
-private:
-  ErrorStatus m_status;
-};
-
-} // namespace Cairo
-
-#endif // __CAIRO_EXCEPTION_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/fontface.cc b/libs/cairomm/cairomm/fontface.cc
deleted file mode 100644
index 0e1642a45a..0000000000
--- a/libs/cairomm/cairomm/fontface.cc
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/fontface.h>
-#include <cairomm/private.h>
-
-namespace Cairo
-{
-
-FontFace::FontFace(cairo_font_face_t* cobject, bool has_reference)
-: m_cobject(0)
-{
-  if(has_reference)
-    m_cobject = cobject;
-  else
-    m_cobject = cairo_font_face_reference(cobject);
-}
-
-FontFace::~FontFace()
-{
-  if(m_cobject)
-    cairo_font_face_destroy(m_cobject);
-}
-
-void FontFace::reference() const
-{
- cairo_font_face_reference(m_cobject);
-}
-
-void FontFace::unreference() const
-{
-  cairo_font_face_destroy(m_cobject);
-}
-
-/*
-void* FontFace::get_user_data(const cairo_user_data_key_t *key)
-{
-  void* result = cairo_font_face_get_user_data(m_cobject, key);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void FontFace::set_user_data(const cairo_user_data_key_t* key, void *user_data, cairo_destroy_func_t destroy)
-{
-  const ErrorStatus status = (ErrorStatus)cairo_font_face_set_user_data(m_cobject, key, user_data, destroy);
-  check_status_and_throw_exception(status);
-}
-*/
-
-FontType FontFace::get_type() const
-{
-  cairo_font_type_t font_type = cairo_font_face_get_type(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return static_cast<FontType>(font_type);
-}
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/fontface.h b/libs/cairomm/cairomm/fontface.h
deleted file mode 100644
index 612820cc8b..0000000000
--- a/libs/cairomm/cairomm/fontface.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_FONTFACE_H
-#define __CAIROMM_FONTFACE_H
-
-#include <cairomm/enums.h>
-#include <cairo.h>
-
-
-namespace Cairo
-{
-
-/**
- * This is a reference-counted object that should be used via Cairo::RefPtr.
- */
-class FontFace
-{
-protected:
-
-  //TODO?: FontFace(cairo_font_face_t *target);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference.
-   */
-  explicit FontFace(cairo_font_face_t* cobject, bool has_reference = false);
-
-
-  virtual ~FontFace();
-
-  /* Don't wrap these until we know what they are good for.
-  void* get_user_data(const cairo_user_data_key_t *key);
-
-  void set_user_data(const cairo_user_data_key_t *key, void *user_data, cairo_destroy_func_t destroy);
-  */
-
-  FontType get_type() const;
-
-  typedef cairo_font_face_t cobject;
-  inline cobject* cobj() { return m_cobject; }
-  inline const cobject* cobj() const { return m_cobject; }
-
-  #ifndef DOXYGEN_IGNORE_THIS
-  ///For use only by the cairomm implementation.
-  inline ErrorStatus get_status() const
-  { return cairo_font_face_status(const_cast<cairo_font_face_t*>(cobj())); }
-  #endif //DOXYGEN_IGNORE_THIS
-
-  void reference() const;
-  void unreference() const;
-
-protected:
-
-  cobject* m_cobject;
-};
-
-} // namespace Cairo
-
-#endif //__CAIROMM_FONTFACE_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/fontoptions.cc b/libs/cairomm/cairomm/fontoptions.cc
deleted file mode 100644
index 864037c8fb..0000000000
--- a/libs/cairomm/cairomm/fontoptions.cc
+++ /dev/null
@@ -1,159 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/fontoptions.h>
-#include <cairomm/private.h>
-
-namespace Cairo
-{
-
-FontOptions::FontOptions()
-: m_cobject(0)
-{
-  m_cobject = cairo_font_options_create();
-  check_object_status_and_throw_exception(*this);
-}
-
-FontOptions::FontOptions(cairo_font_options_t* cobject, bool take_ownership)
-: m_cobject(0)
-{
-  if(take_ownership)
-    m_cobject = cobject;
-  else
-    m_cobject = cairo_font_options_copy(cobject);
-
-  check_object_status_and_throw_exception(*this);
-}
-
-FontOptions::FontOptions(const FontOptions& src)
-{
-  //Reference-counting, instead of copying by value:
-  if(!src.m_cobject)
-    m_cobject = 0;
-  else
-    m_cobject = cairo_font_options_copy(src.m_cobject);
-
-  check_object_status_and_throw_exception(*this);
-}
-
-FontOptions::~FontOptions()
-{
-  if(m_cobject)
-    cairo_font_options_destroy(m_cobject);
-}
-
-
-FontOptions& FontOptions::operator=(const FontOptions& src)
-{
-  //Reference-counting, instead of copying by value:
-
-  if(this == &src)
-    return *this;
-
-  if(m_cobject == src.m_cobject)
-    return *this;
-
-  if(m_cobject)
-  {
-    cairo_font_options_destroy(m_cobject);
-    m_cobject = 0;
-  }
-
-  if(!src.m_cobject)
-    return *this;
-
-  m_cobject = cairo_font_options_copy(src.m_cobject);
-
-  return *this;
-}
-
-bool FontOptions::operator==(const FontOptions& src) const
-{
-  return cairo_font_options_equal(m_cobject, src.cobj());
-}
-
-void FontOptions::merge(const FontOptions& src)
-{
-  cairo_font_options_merge(m_cobject, src.cobj());
-  check_object_status_and_throw_exception(*this);
-}
-
-unsigned long FontOptions::hash() const
-{
-  const unsigned long result = cairo_font_options_hash(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void FontOptions::set_antialias(Antialias antialias)
-{
-  cairo_font_options_set_antialias(m_cobject, static_cast<cairo_antialias_t>(antialias));
-  check_object_status_and_throw_exception(*this);
-}
-
-Antialias FontOptions::get_antialias() const
-{
-  const Antialias result = static_cast<Antialias>(cairo_font_options_get_antialias(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void FontOptions::set_subpixel_order(SubpixelOrder subpixel_order)
-{
-  cairo_font_options_set_subpixel_order(m_cobject, static_cast<cairo_subpixel_order_t>(subpixel_order));
-  check_object_status_and_throw_exception(*this);
-}
-
-SubpixelOrder FontOptions::get_subpixel_order() const
-{
-  const SubpixelOrder result = static_cast<SubpixelOrder>(cairo_font_options_get_subpixel_order(m_cobject));
-  check_object_status_and_throw_exception(*this); 
-  return result;
-}
-
-void FontOptions::set_hint_style(HintStyle hint_style)
-{
-  cairo_font_options_set_hint_style(m_cobject, static_cast<cairo_hint_style_t>(hint_style));
-  check_object_status_and_throw_exception(*this);
-}
-
-HintStyle FontOptions::get_hint_style() const
-{
-  const HintStyle result = static_cast<HintStyle>(cairo_font_options_get_hint_style(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void FontOptions::set_hint_metrics(HintMetrics hint_metrics)
-{
-  cairo_font_options_set_hint_metrics(m_cobject,
-          static_cast<cairo_hint_metrics_t>(hint_metrics));
-  check_object_status_and_throw_exception(*this);
-}
-
-HintMetrics FontOptions::get_hint_metrics() const
-{
-  const HintMetrics result =
-      static_cast<HintMetrics>(cairo_font_options_get_hint_metrics(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/fontoptions.h b/libs/cairomm/cairomm/fontoptions.h
deleted file mode 100644
index 3c35176121..0000000000
--- a/libs/cairomm/cairomm/fontoptions.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_FONTOPTIONS_H
-#define __CAIROMM_FONTOPTIONS_H
-
-#include <cairomm/enums.h>
-#include <string>
-#include <cairo.h>
-
-
-namespace Cairo
-{
-
-/** How a font should be rendered.
- */
-class FontOptions
-{
-public:
-  FontOptions();
-  explicit FontOptions(cairo_font_options_t* cobject, bool take_ownership = false);
-  FontOptions(const FontOptions& src);
-
-  virtual ~FontOptions();
-
-  FontOptions& operator=(const FontOptions& src);
-
-  bool operator ==(const FontOptions& src) const;
-  //bool operator !=(const FontOptions& src) const;
-
-  void merge(const FontOptions& other);
-
-  unsigned long hash() const;
-
-  void set_antialias(Antialias antialias);
-  Antialias get_antialias() const;
-
-  void set_subpixel_order(SubpixelOrder subpixel_order);
-  SubpixelOrder get_subpixel_order() const;
-
-  void set_hint_style(HintStyle hint_style);
-  HintStyle get_hint_style() const;
-
-  void set_hint_metrics(HintMetrics hint_metrics);
-  HintMetrics get_hint_metrics() const;
-
-  typedef cairo_font_options_t cobject;
-  inline cobject* cobj() { return m_cobject; }
-  inline const cobject* cobj() const { return m_cobject; }
-
-  #ifndef DOXYGEN_IGNORE_THIS
-  ///For use only by the cairomm implementation.
-  inline ErrorStatus get_status() const
-  { return cairo_font_options_status(const_cast<cairo_font_options_t*>(cobj())); }
-  #endif //DOXYGEN_IGNORE_THIS
-
-protected:
-
-  cobject* m_cobject;
-};
-
-} // namespace Cairo
-
-#endif //__CAIROMM_FONTOPTIONS_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/path.cc b/libs/cairomm/cairomm/path.cc
deleted file mode 100644
index 8040aa3e6b..0000000000
--- a/libs/cairomm/cairomm/path.cc
+++ /dev/null
@@ -1,98 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/path.h>
-#include <cairomm/private.h>
-#include <iostream>
-
-namespace Cairo
-{
-
-/*
-Path::Path()
-: m_cobject(0)
-{
-  m_cobject = cairo_path_create();
-}
-*/
-
-Path::Path(cairo_path_t* cobject, bool take_ownership)
-: m_cobject(0)
-{
-  if(take_ownership)
-    m_cobject = cobject;
-  else
-  {
-    std::cerr << "cairomm: Path::Path(): copying of the underlying cairo_path_t* is not yet implemented." << std::endl;
-    //m_cobject = cairo_path_copy(cobject);
-  }
-}
-
-/*
-Path::Path(const Path& src)
-{
-  //Reference-counting, instead of copying by value:
-  if(!src.m_cobject)
-    m_cobject = 0;
-  else
-    m_cobject = cairo_path_copy(src.m_cobject);
-}
-*/
-
-Path::~Path()
-{
-  if(m_cobject)
-    cairo_path_destroy(m_cobject);
-}
-
-/*
-Path& Path::operator=(const Path& src)
-{
-  //Reference-counting, instead of copying by value:
-
-  if(this == &src)
-    return *this;
-
-  if(m_cobject == src.m_cobject)
-    return *this;
-
-  if(m_cobject)
-  {
-    cairo_path_destroy(m_cobject);
-    m_cobject = 0;
-  }
-
-  if(!src.m_cobject)
-    return *this;
-
-  m_cobject = cairo_path_copy(src.m_cobject);
-
-  return *this;
-}
-*/
-
-/*
-bool Path::operator==(const Path& src) const
-{
-  return cairo_path_equal(m_cobject, src.cobj());
-}
-*/
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/path.h b/libs/cairomm/cairomm/path.h
deleted file mode 100644
index f5f7480908..0000000000
--- a/libs/cairomm/cairomm/path.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_PATH_H
-#define __CAIROMM_PATH_H
-
-#include <cairomm/enums.h>
-#include <string>
-#include <cairo.h>
-
-
-namespace Cairo
-{
-
-/** A data structure for holding a path.
- * Use Context::copy_path() or Context::copy_path_flat() to instantiate a new
- * Path.  The application is responsible for freeing the Path object when it is
- * no longer needed.
- *
- * @todo There's currently no way to access the path data without reverting to
- * the C object (see cobj())
- */
-class Path
-{
-public:
-  //Path();
-  explicit Path(cairo_path_t* cobject, bool take_ownership = false);
-  //Path(const Path& src);
-
-  virtual ~Path();
-
-  //Path& operator=(const Path& src);
-
-  //bool operator ==(const Path& src) const;
-  //bool operator !=(const Path& src) const;
-
-  typedef cairo_path_t cobject;
-  inline cobject* cobj() { return m_cobject; }
-  inline const cobject* cobj() const { return m_cobject; }
-
-  #ifndef DOXYGEN_IGNORE_THIS
-  ///For use only by the cairomm implementation.
-  //There is no *_status() function for this object:
-  //inline ErrorStatus get_status() const
-  //{ return cairo_path_status(const_cast<cairo_path_t*>(cobj())); }
-  #endif //DOXYGEN_IGNORE_THIS
-
-protected:
-
-  cobject* m_cobject;
-};
-
-} // namespace Cairo
-
-#endif //__CAIROMM_PATH_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/pattern.cc b/libs/cairomm/cairomm/pattern.cc
deleted file mode 100644
index 27638cd400..0000000000
--- a/libs/cairomm/cairomm/pattern.cc
+++ /dev/null
@@ -1,219 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/pattern.h>
-#include <cairomm/private.h>
-
-namespace Cairo
-{
-
-Pattern::Pattern()
-: m_cobject(0)
-{
-}
-
-Pattern::Pattern(cairo_pattern_t* cobject, bool has_reference)
-: m_cobject(0)
-{
-  if(has_reference)
-    m_cobject = cobject;
-  else
-    m_cobject = cairo_pattern_reference(cobject);
-}
-
-Pattern::~Pattern()
-{
-  if(m_cobject)
-    cairo_pattern_destroy(m_cobject);
-}
-
-void Pattern::reference() const
-{
- cairo_pattern_reference(m_cobject);
-}
-
-void Pattern::unreference() const
-{
-  cairo_pattern_destroy(m_cobject);
-}
-
-void Pattern::set_matrix(const cairo_matrix_t &matrix)
-{
-  cairo_pattern_set_matrix(m_cobject, &matrix);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Pattern::get_matrix(cairo_matrix_t &matrix) const
-{
-  cairo_pattern_get_matrix(m_cobject, &matrix);
-  check_object_status_and_throw_exception(*this);
-}
-
-PatternType Pattern::get_type() const
-{
-  cairo_pattern_type_t pattern_type = cairo_pattern_get_type(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return static_cast<PatternType>(pattern_type);
-}
-
-
-
-SolidPattern::SolidPattern(cairo_pattern_t* cobject, bool has_reference)
-: Pattern(cobject, has_reference)
-{
-}
-
-SolidPattern::~SolidPattern()
-{
-}
-
-RefPtr<SolidPattern> SolidPattern::create_rgb(double red, double green, double blue)
-{
-  cairo_pattern_t* cobject = cairo_pattern_create_rgb(red, green, blue);
-  check_status_and_throw_exception(cairo_pattern_status(cobject)); 
-  return RefPtr<SolidPattern>(new SolidPattern(cobject, true /* has reference */));
-}
-
-RefPtr<SolidPattern> SolidPattern::create_rgba(double red, double green, double blue, double alpha)
-{
-  cairo_pattern_t* cobject  = cairo_pattern_create_rgba(red, green, blue, alpha);
-  check_status_and_throw_exception(cairo_pattern_status(cobject));
-  return RefPtr<SolidPattern>(new SolidPattern(cobject, true /* has reference */));
-}
-
-
-SurfacePattern::SurfacePattern(const RefPtr<Surface>& surface)
-{
-  m_cobject = cairo_pattern_create_for_surface(surface->cobj());
-  check_object_status_and_throw_exception(*this); 
-}
-
-RefPtr<SurfacePattern> SurfacePattern::create(const RefPtr<Surface>& surface)
-{
-  return RefPtr<SurfacePattern>(new SurfacePattern(surface));
-}
-
-SurfacePattern::SurfacePattern(cairo_pattern_t* cobject, bool has_reference)
-: Pattern(cobject, has_reference)
-{
-}
-
-SurfacePattern::~SurfacePattern()
-{
-}
-
-void SurfacePattern::set_extend(Extend extend)
-{
-  cairo_pattern_set_extend(m_cobject, (cairo_extend_t)extend);
-  check_object_status_and_throw_exception(*this);
-}
-
-Extend SurfacePattern::get_extend() const
-{
-  const Extend result = static_cast<Extend>(cairo_pattern_get_extend(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-void SurfacePattern::set_filter(Filter filter)
-{
-  cairo_pattern_set_filter(m_cobject, (cairo_filter_t)filter);
-  check_object_status_and_throw_exception(*this);
-}
-
-Filter SurfacePattern::get_filter() const
-{
-  Filter result = static_cast<Filter>(cairo_pattern_get_filter(m_cobject));
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-
-
-Gradient::Gradient()
-{
-}
-
-Gradient::Gradient(cairo_pattern_t* cobject, bool has_reference)
-: Pattern(cobject, has_reference)
-{
-}
-
-Gradient::~Gradient()
-{
-}
-
-void Gradient::add_color_stop_rgb(double offset, double red, double green, double blue)
-{
-  cairo_pattern_add_color_stop_rgb(m_cobject, offset, red, green, blue);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Gradient::add_color_stop_rgba(double offset, double red, double green, double blue, double alpha)
-{
-  cairo_pattern_add_color_stop_rgba(m_cobject, offset, red, green, blue, alpha);
-  check_object_status_and_throw_exception(*this);
-}
-
-
-
-LinearGradient::LinearGradient(double x0, double y0, double x1, double y1)
-{
-  m_cobject = cairo_pattern_create_linear(x0, y0, x1, y1);
-  check_object_status_and_throw_exception(*this); 
-}
-
-RefPtr<LinearGradient> LinearGradient::create(double x0, double y0, double x1, double y1)
-{
-  return RefPtr<LinearGradient>(new LinearGradient(x0, y0, x1, y1));
-}
-
-LinearGradient::LinearGradient(cairo_pattern_t* cobject, bool has_reference)
-: Gradient(cobject, has_reference)
-{
-}
-
-LinearGradient::~LinearGradient()
-{
-}
-
-
-RadialGradient::RadialGradient(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1)
-{
-  m_cobject = cairo_pattern_create_radial(cx0, cy0, radius0, cx1, cy1, radius1);
-  check_object_status_and_throw_exception(*this); 
-}
-
-RefPtr<RadialGradient> RadialGradient::create(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1)
-{
-  return RefPtr<RadialGradient>(new RadialGradient(cx0, cy0, radius0, cx1, cy1, radius1));
-}
-
-RadialGradient::RadialGradient(cairo_pattern_t* cobject, bool has_reference)
-: Gradient(cobject, has_reference)
-{
-}
-
-RadialGradient::~RadialGradient()
-{
-}
-
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/pattern.h b/libs/cairomm/cairomm/pattern.h
deleted file mode 100644
index 2624d7a5d9..0000000000
--- a/libs/cairomm/cairomm/pattern.h
+++ /dev/null
@@ -1,189 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_PATTERN_H
-#define __CAIROMM_PATTERN_H
-
-#include <cairomm/surface.h>
-#include <cairomm/enums.h>
-#include <cairo.h>
-
-
-namespace Cairo
-{
-
-/**
- * This is a reference-counted object that should be used via Cairo::RefPtr.
- */
-class Pattern
-{
-protected:
-  //Use derived constructors.
-
-  //TODO?: Pattern(cairo_pattern_t *target);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference.
-   */
-  explicit Pattern(cairo_pattern_t* cobject, bool has_reference = false);
-
-  virtual ~Pattern();
-
-  void set_matrix(const cairo_matrix_t &matrix);
-  void get_matrix(cairo_matrix_t &matrix) const;
-  PatternType get_type() const;
-
-  typedef cairo_pattern_t cobject;
-  inline cobject* cobj() { return m_cobject; }
-  inline const cobject* cobj() const { return m_cobject; }
-
-  #ifndef DOXYGEN_IGNORE_THIS
-  ///For use only by the cairomm implementation.
-  inline ErrorStatus get_status() const
-  { return cairo_pattern_status(const_cast<cairo_pattern_t*>(cobj())); }
-  #endif //DOXYGEN_IGNORE_THIS
-
-  void reference() const;
-  void unreference() const;
-
-protected:
-  //Used by derived types only.
-  Pattern();
-
-  cobject* m_cobject;
-};
-
-class SolidPattern : public Pattern
-{
-protected:
-
-public:
-
-  /** Create a C++ wrapper for the C instance.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference.
-   */
-  explicit SolidPattern(cairo_pattern_t* cobject, bool has_reference = false);
-
-  static RefPtr<SolidPattern> create_rgb(double red, double green, double blue);
-  static RefPtr<SolidPattern> create_rgba(double red, double green, double blue, double alpha);
-
-  //TODO?: SolidPattern(cairo_pattern_t *target);
-  virtual ~SolidPattern();
-};
-
-class SurfacePattern : public Pattern
-{
-protected:
-
-  explicit SurfacePattern(const RefPtr<Surface>& surface);
-
-  //TODO?: SurfacePattern(cairo_pattern_t *target);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference.
-   */
-  explicit SurfacePattern(cairo_pattern_t* cobject, bool has_reference = false);
-
-
-  virtual ~SurfacePattern();
-
-  static RefPtr<SurfacePattern> create(const RefPtr<Surface>& surface);
-
-  void set_extend(Extend extend);
-  Extend get_extend() const;
-  void set_filter(Filter filter);
-  Filter get_filter() const;
-};
-
-class Gradient : public Pattern
-{
-protected:
-  //Use derived constructors.
-
-  //TODO?: Gradient(cairo_pattern_t *target);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference.
-   */
-  explicit Gradient(cairo_pattern_t* cobject, bool has_reference = false);
-
-  virtual ~Gradient();
-
-  void add_color_stop_rgb(double offset, double red, double green, double blue);
-  void add_color_stop_rgba(double offset, double red, double green, double blue, double alpha);
-
-protected:
-  Gradient();
-};
-
-class LinearGradient : public Gradient
-{
-protected:
-
-  LinearGradient(double x0, double y0, double x1, double y1);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference.
-   */
-  explicit LinearGradient(cairo_pattern_t* cobject, bool has_reference = false);
-
-  //TODO?: LinearGradient(cairo_pattern_t *target);
-  virtual ~LinearGradient();
-
-  static RefPtr<LinearGradient> create(double x0, double y0, double x1, double y1);
-};
-
-class RadialGradient : public Gradient
-{
-protected:
-
-  RadialGradient(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be given to a RefPtr.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the constructor will take an extra reference.
-   */
-  explicit RadialGradient(cairo_pattern_t* cobject, bool has_reference = false);
-
-
-  //TODO?: RadialGradient(cairo_pattern_t *target);
-  virtual ~RadialGradient();
-
-  static RefPtr<RadialGradient> create(double cx0, double cy0, double radius0, double cx1, double cy1, double radius1);
-};
-
-} // namespace Cairo
-
-#endif //__CAIROMM_PATTERN_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/private.cc b/libs/cairomm/cairomm/private.cc
deleted file mode 100644
index 68d09f9562..0000000000
--- a/libs/cairomm/cairomm/private.cc
+++ /dev/null
@@ -1,76 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/private.h>
-#include <cairomm/exception.h>
-#include <stdexcept>
-#include <iostream>
-
-namespace Cairo
-{
-
-void throw_exception(ErrorStatus status)
-{
-  switch(status)
-  {
-    case CAIRO_STATUS_SUCCESS:
-      // we should never get here, but just in case
-      break;
-
-    case CAIRO_STATUS_NO_MEMORY:
-      throw std::bad_alloc();
-      break;
-
-    // Programmer error
-    case CAIRO_STATUS_INVALID_RESTORE:
-    case CAIRO_STATUS_INVALID_POP_GROUP:
-    case CAIRO_STATUS_NO_CURRENT_POINT:
-    case CAIRO_STATUS_INVALID_MATRIX:
-    //No longer in API?: case CAIRO_STATUS_NO_TARGET_SURFACE:
-    case CAIRO_STATUS_INVALID_STRING:
-    case CAIRO_STATUS_SURFACE_FINISHED:
-    //No longer in API?: case CAIRO_STATUS_BAD_NESTING:
-      throw Cairo::logic_error(status);
-      break;
-
-    // Language binding implementation:
-    case CAIRO_STATUS_NULL_POINTER:
-    case CAIRO_STATUS_INVALID_PATH_DATA:
-    case CAIRO_STATUS_SURFACE_TYPE_MISMATCH:
-      throw Cairo::logic_error(status);
-      break;
-
-    // Other      
-    case CAIRO_STATUS_READ_ERROR:
-    case CAIRO_STATUS_WRITE_ERROR:
-    {
-      //The Cairo language binding advice suggests that these are stream errors 
-      //that should be mapped to their C++ equivalents.
-      const char* error_message = cairo_status_to_string(status);
-      throw std::ios_base::failure( error_message ? error_message : std::string() );
-    }
-    
-    default:
-      throw Cairo::logic_error(status);
-      break;
-  }
-}
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/private.h b/libs/cairomm/cairomm/private.h
deleted file mode 100644
index 7b18c5bc21..0000000000
--- a/libs/cairomm/cairomm/private.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_PRIVATE_H
-#define __CAIROMM_PRIVATE_H
-
-#include <cairomm/enums.h>
-#include <cairomm/exception.h>
-#include <string>
-
-
-namespace Cairo
-{
-
-void throw_exception(ErrorStatus status);
-
-//We inline this because it is called so often.
-inline void check_status_and_throw_exception(ErrorStatus status)
-{
-  if(status != CAIRO_STATUS_SUCCESS)
-    throw_exception(status); //This part doesn't need to be inline because it would rarely be called.
-}
-
-template<class T>
-void check_object_status_and_throw_exception(const T& object)
-{
-  //get_status() is normally an inlined member method.
-  check_status_and_throw_exception(object.get_status());
-}
-
-} // namespace Cairo
-
-#endif //__CAIROMM_PRIVATE_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/refptr.h b/libs/cairomm/cairomm/refptr.h
deleted file mode 100644
index c346fe0001..0000000000
--- a/libs/cairomm/cairomm/refptr.h
+++ /dev/null
@@ -1,391 +0,0 @@
-// -*- c++ -*-
-#ifndef _cairo_REFPTR_H
-#define _cairo_REFPTR_H
-
-/* $Id: refptr.h,v 1.6 2006/09/27 18:38:57 murrayc Exp $ */
-
-/* Copyright 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-
-namespace Cairo
-{
-
-/** RefPtr<> is a reference-counting shared smartpointer.
- *
- * Reference counting means that a shared reference count is incremented each
- * time a RefPtr is copied, and decremented each time a RefPtr is destroyed,
- * for instance when it leaves its scope. When the reference count reaches
- * zero, the contained object is deleted
- *
- * cairomm uses RefPtr so that you don't need to remember
- * to delete the object explicitly, or know when a method expects you to delete 
- * the object that it returns, and to prevent any need to manually  reference 
- * and unreference() cairo objects.
- */
-template <class T_CppObject>
-class RefPtr
-{
-public:
-  /** Default constructor
-   *
-   * Afterwards it will be null and use of -> will cause a segmentation fault.
-   */
-  inline RefPtr();
-  
-  /// Destructor - decrements reference count.
-  inline ~RefPtr();
-
-  /** For use only in the internal implementation of cairomm, gtkmm, etc.
-   *
-   * This takes ownership of @a pCppObject, so it will be deleted when the 
-   * last RefPtr is deleted, for instance when it goes out of scope.
-   *
-   * This assumes that @a pCppObject already has a starting reference for its underlying cairo object,
-   * so that destruction of @a @pCppObject will cause a corresponding unreference of its underlying 
-   * cairo object. For instance, a cairo_*_create() function usually provides a starting reference, 
-   * but a cairo_*_get_*() function requires the caller to manually reference the returned object.
-   * In this case, you should call reference() on @a pCppObject before passing it to this constructor.
-   */
-  explicit inline RefPtr(T_CppObject* pCppObject);
-
-  /** Copy constructor
-   *
-   * This increments the shared reference count.
-   */
-  inline RefPtr(const RefPtr<T_CppObject>& src);
-
-  /** Copy constructor (from different, but castable type).
-   *
-   * Increments the reference count.
-   */
-  template <class T_CastFrom>
-  inline RefPtr(const RefPtr<T_CastFrom>& src);
-
-  /** Swap the contents of two RefPtr<>.
-   * This method swaps the internal pointers to T_CppObject.  This can be
-   * done safely without involving a reference/unreference cycle and is
-   * therefore highly efficient.
-   */
-  inline void swap(RefPtr<T_CppObject>& other);
-
-  /// Copy from another RefPtr:
-  inline RefPtr<T_CppObject>& operator=(const RefPtr<T_CppObject>& src);
-
-  /** Copy from different, but castable type).
-   *
-   * Increments the reference count.
-   */
-  template <class T_CastFrom>
-  inline RefPtr<T_CppObject>& operator=(const RefPtr<T_CastFrom>& src);
-
-  /// Tests whether the RefPtr<> point to the same underlying instance.
-  inline bool operator==(const RefPtr<T_CppObject>& src) const;
-  
-  /// See operator==().
-  inline bool operator!=(const RefPtr<T_CppObject>& src) const;
-
-  /** Dereferencing.
-   *
-   * Use the methods of the underlying instance like so:
-   * <code>refptr->memberfun()</code>.
-   */
-  inline T_CppObject* operator->() const;
-
-  /** Test whether the RefPtr<> points to any underlying instance.
-   *
-   * Mimics usage of ordinary pointers:
-   * @code
-   *   if (ptr)
-   *     do_something();
-   * @endcode
-   */
-  inline operator bool() const;
-
-  /// Set underlying instance to 0, decrementing reference count of existing instance appropriately.
-  inline void clear();
-
-
-  /** Dynamic cast to derived class.
-   *
-   * The RefPtr can't be cast with the usual notation so instead you can use
-   * @code
-   *   ptr_derived = RefPtr<Derived>::cast_dynamic(ptr_base);
-   * @endcode
-   */
-  template <class T_CastFrom>
-  static inline RefPtr<T_CppObject> cast_dynamic(const RefPtr<T_CastFrom>& src);
-
-  /** Static cast to derived class.
-   *
-   * Like the dynamic cast; the notation is 
-   * @code
-   *   ptr_derived = RefPtr<Derived>::cast_static(ptr_base);
-   * @endcode
-   */
-  template <class T_CastFrom>
-  static inline RefPtr<T_CppObject> cast_static(const RefPtr<T_CastFrom>& src);
-
-  /** Cast to non-const.
-   *
-   * The RefPtr can't be cast with the usual notation so instead you can use
-   * @code
-   *   ptr_unconst = RefPtr<UnConstType>::cast_const(ptr_const);
-   * @endcode
-   */
-  template <class T_CastFrom>
-  static inline RefPtr<T_CppObject> cast_const(const RefPtr<T_CastFrom>& src);
-
-
-#ifndef DOXYGEN_IGNORE_THIS
-
-  // Warning: This is for internal use only.  Do not manually modify the
-  // reference count with this pointer.
-  inline int* refcount_() const { return pCppRefcount_; }
-
-#endif // DOXYGEN_IGNORE_THIS
-
-private:
-  void unref();
-
-  T_CppObject* pCppObject_;
-  mutable int* pCppRefcount_;
-};
-
-
-#ifndef DOXYGEN_IGNORE_THIS
-
-// RefPtr<>::operator->() comes first here since it's used by other methods.
-// If it would come after them it wouldn't be inlined.
-
-template <class T_CppObject> inline
-T_CppObject* RefPtr<T_CppObject>::operator->() const
-{
-  return pCppObject_;
-}
-
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr()
-:
-  pCppObject_(0),
-  pCppRefcount_(0)
-{}
-
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::~RefPtr()
-{
-  unref();
-}
-
-template <class T_CppObject> inline
-void RefPtr<T_CppObject>::unref()
-{
-  if(pCppRefcount_)
-  {
-    --(*pCppRefcount_);
-
-    if(*pCppRefcount_ == 0)
-    {
-      if(pCppObject_)
-      {
-        delete pCppObject_;
-        pCppObject_ = 0;
-      }
-
-      delete pCppRefcount_;
-      pCppRefcount_ = 0;
-    }
-  }
-}
-
-
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr(T_CppObject* pCppObject)
-:
-  pCppObject_(pCppObject),
-  pCppRefcount_(0)
-{
-  if(pCppObject)
-  {
-    pCppRefcount_ = new int;
-    *pCppRefcount_ = 1; //This will be decremented in the destructor.
-  }
-}
-
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr(const RefPtr<T_CppObject>& src)
-:
-  pCppObject_ (src.pCppObject_),
-  pCppRefcount_(src.pCppRefcount_)
-{
-  if(pCppObject_ && pCppRefcount_)
-    ++(*pCppRefcount_);
-}
-
-// The templated ctor allows copy construction from any object that's
-// castable.  Thus, it does downcasts:
-//   base_ref = derived_ref
-template <class T_CppObject>
-  template <class T_CastFrom>
-inline
-RefPtr<T_CppObject>::RefPtr(const RefPtr<T_CastFrom>& src)
-:
-  // A different RefPtr<> will not allow us access to pCppObject_.  We need
-  // to add a get_underlying() for this, but that would encourage incorrect
-  // use, so we use the less well-known operator->() accessor:
-  pCppObject_ (src.operator->()),
-  pCppRefcount_(src.refcount_())
-{
-  if(pCppObject_ && pCppRefcount_)
-    ++(*pCppRefcount_);
-}
-
-template <class T_CppObject> inline
-void RefPtr<T_CppObject>::swap(RefPtr<T_CppObject>& other)
-{
-  T_CppObject *const temp = pCppObject_;
-  int* temp_count = pCppRefcount_; 
-
-  pCppObject_ = other.pCppObject_;
-  pCppRefcount_ = other.pCppRefcount_;
-
-  other.pCppObject_ = temp;
-  other.pCppRefcount_ = temp_count;
-}
-
-template <class T_CppObject> inline
-RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr<T_CppObject>& src)
-{
-  // In case you haven't seen the swap() technique to implement copy
-  // assignment before, here's what it does:
-  //
-  // 1) Create a temporary RefPtr<> instance via the copy ctor, thereby
-  //    increasing the reference count of the source object.
-  //
-  // 2) Swap the internal object pointers of *this and the temporary
-  //    RefPtr<>.  After this step, *this already contains the new pointer,
-  //    and the old pointer is now managed by temp.
-  //
-  // 3) The destructor of temp is executed, thereby unreferencing the
-  //    old object pointer.
-  //
-  // This technique is described in Herb Sutter's "Exceptional C++", and
-  // has a number of advantages over conventional approaches:
-  //
-  // - Code reuse by calling the copy ctor.
-  // - Strong exception safety for free.
-  // - Self assignment is handled implicitely.
-  // - Simplicity.
-  // - It just works and is hard to get wrong; i.e. you can use it without
-  //   even thinking about it to implement copy assignment whereever the
-  //   object data is managed indirectly via a pointer, which is very common.
-
-  RefPtr<T_CppObject> temp (src);
-  this->swap(temp);
-  return *this;
-}
-
-template <class T_CppObject>
-  template <class T_CastFrom>
-inline
-RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr<T_CastFrom>& src)
-{
-  RefPtr<T_CppObject> temp (src);
-  this->swap(temp);
-  return *this;
-}
-
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator==(const RefPtr<T_CppObject>& src) const
-{
-  return (pCppObject_ == src.pCppObject_);
-}
-
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator!=(const RefPtr<T_CppObject>& src) const
-{
-  return (pCppObject_ != src.pCppObject_);
-}
-
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::operator bool() const
-{
-  return (pCppObject_ != 0);
-}
-
-template <class T_CppObject> inline
-void RefPtr<T_CppObject>::clear()
-{
-  RefPtr<T_CppObject> temp; // swap with an empty RefPtr<> to clear *this
-  this->swap(temp);
-}
-
-template <class T_CppObject>
-  template <class T_CastFrom>
-inline
-RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_dynamic(const RefPtr<T_CastFrom>& src)
-{
-  T_CppObject *const pCppObject = dynamic_cast<T_CppObject*>(src.operator->());
-
-  if(pCppObject && src.refcount_())
-    ++(*(src.refcount_()));
-
-  return RefPtr<T_CppObject>(pCppObject); //TODO: Does an unnecessary extra reference() on the C object.
-}
-
-template <class T_CppObject>
-  template <class T_CastFrom>
-inline
-RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_static(const RefPtr<T_CastFrom>& src)
-{
-  T_CppObject *const pCppObject = static_cast<T_CppObject*>(src.operator->());
-
-  if(pCppObject && src.refcount_())
-    ++(*(src.refcount_()));
-
-  return RefPtr<T_CppObject>(pCppObject); //TODO: Does an unnecessary extra reference() on the C object.
-}
-
-template <class T_CppObject>
-  template <class T_CastFrom>
-inline
-RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_const(const RefPtr<T_CastFrom>& src)
-{
-  T_CppObject *const pCppObject = const_cast<T_CppObject*>(src.operator->());
-
-  if(pCppObject && src.refcount_())
-    ++(*(src.refcount_()));
-
-  return RefPtr<T_CppObject>(pCppObject); //TODO: Does an unnecessary extra reference() on the C object.
-}
-
-#endif /* DOXYGEN_IGNORE_THIS */
-
-/** @relates Glib::RefPtr */
-template <class T_CppObject> inline
-void swap(RefPtr<T_CppObject>& lhs, RefPtr<T_CppObject>& rhs)
-{
-  lhs.swap(rhs);
-}
-
-} // namespace Cairo
-
-
-#endif /* _cairo_REFPTR_H */
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/scaledfont.cc b/libs/cairomm/cairomm/scaledfont.cc
deleted file mode 100644
index 02fb11c567..0000000000
--- a/libs/cairomm/cairomm/scaledfont.cc
+++ /dev/null
@@ -1,104 +0,0 @@
-/* Copyright (C) 2006 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/scaledfont.h>
-#include <cairomm/private.h>  // for check_status_and_throw_exception
-
-namespace Cairo
-{
-
-ScaledFont::ScaledFont(cobject* cobj, bool has_reference)
-{
-  if(has_reference)
-    m_cobject = cobj;
-  else
-    m_cobject = cairo_scaled_font_reference(cobj);
-}
-
-RefPtr<ScaledFont> ScaledFont::create(FontFace& font_face, const Matrix& font_matrix,
-    const Matrix& ctm, const FontOptions& options)
-{
-  cairo_scaled_font_t* cobj = cairo_scaled_font_create(font_face.cobj(), &font_matrix, &ctm, options.cobj());
-  check_status_and_throw_exception(cairo_scaled_font_status(cobj));
-  return RefPtr<ScaledFont>(new ScaledFont(cobj, false));
-}
-
-void ScaledFont::extents(FontExtents& extents) const
-{
-  cairo_scaled_font_extents(m_cobject, static_cast<cairo_font_extents_t*>(&extents));
-  check_object_status_and_throw_exception(*this);
-}
-
-void ScaledFont::text_extents(const std::string& utf8, TextExtents& extents) const
-{
-  cairo_scaled_font_text_extents(m_cobject, utf8.c_str(), static_cast<cairo_text_extents_t*>(&extents));
-  check_object_status_and_throw_exception(*this);
-}
-
-void ScaledFont::glyph_extents(const std::vector<Glyph>& glyphs, TextExtents& extents)
-{
-  // copy the data from the vector to a standard C array.  I don't believe
-  // this will be a frequently used function so I think the performance hit is
-  // more than offset by the increased flexibility of the STL interface.
-  
-  // Use new to allocate memory as MSCV complains about non-const array size with
-  // Glyph glyph_array[glyphs.size()]
-  Glyph* glyph_array= new Glyph[glyphs.size()];
-  std::copy(glyphs.begin(), glyphs.end(), glyph_array);
-
-  cairo_scaled_font_glyph_extents(m_cobject, glyph_array, glyphs.size(),
-      static_cast<cairo_text_extents_t*>(&extents));
-  check_object_status_and_throw_exception(*this);
-  delete[] glyph_array;
-}
-
-RefPtr<FontFace> ScaledFont::get_font_face() const
-{
-  cairo_font_face_t* face = cairo_scaled_font_get_font_face(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return RefPtr<FontFace>(new FontFace(face, true));
-}
-
-void ScaledFont::get_font_options(FontOptions& options) const
-{
-  cairo_scaled_font_get_font_options(m_cobject, options.cobj());
-  check_object_status_and_throw_exception(*this);
-}
-
-void ScaledFont::get_font_matrix(Matrix& font_matrix) const
-{
-  cairo_scaled_font_get_font_matrix(m_cobject,
-      static_cast<cairo_matrix_t*>(&font_matrix));
-  check_object_status_and_throw_exception(*this);
-}
-
-void ScaledFont::get_ctm(Matrix& ctm) const
-{
-  cairo_scaled_font_get_ctm(m_cobject, static_cast<cairo_matrix_t*>(&ctm));
-  check_object_status_and_throw_exception(*this);
-}
-
-FontType ScaledFont::get_type() const
-{
-  cairo_font_type_t font_type = cairo_scaled_font_get_type(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return static_cast<FontType>(font_type);
-}
-
-}   // namespace Cairo
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/scaledfont.h b/libs/cairomm/cairomm/scaledfont.h
deleted file mode 100644
index 9ad077c7d5..0000000000
--- a/libs/cairomm/cairomm/scaledfont.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/* Copyright (C) 2006 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_SCALEDFONT_H
-#define __CAIROMM_SCALEDFONT_H
-
-#include <cairomm/context.h>
-#include <cairomm/fontoptions.h>
-
-namespace Cairo
-{
-
-typedef enum
-{
-} ScaledFontType;
-
-/** A ScaledFont is a font scaled to a particular size and device resolution. It
- * is most useful for low-level font usage where a library or application wants
- * to cache a reference to a scaled font to speed up the computation of metrics.
- */
-class ScaledFont
-{
-
-public: 
-  /** The underlying C cairo object type */
-  typedef cairo_scaled_font_t cobject;
-
-  /** Provides acces to the underlying C cairo object */
-  inline cobject* cobj() { return m_cobject; }
-
-  /** Provides acces to the underlying C cairo object */
-  inline const cobject* cobj() const { return m_cobject; }
-
-#ifndef DOXYGEN_IGNORE_THIS
-  // For use only by the cairomm implementation.
-  inline ErrorStatus get_status() const
-  { return cairo_scaled_font_status(const_cast<cairo_scaled_font_t*>(cobj())); }
-
-  // for RefPtr
-  void reference() const { cairo_scaled_font_reference(m_cobject); }
-  void unreference() const { cairo_scaled_font_destroy(m_cobject); }
-#endif //DOXYGEN_IGNORE_THIS
-
-  /** Createa C++ wrapper object from the C instance.  This C++ object should
-   * then be given to a RefPtr.
-   */
-  explicit ScaledFont(cobject* cobj, bool has_reference = false);
-
-  /** Creates a ScaledFont object from a font face and matrices that describe
-   * the size of the font and the environment in which it will be used.
-   *
-   * @param font_face A font face.
-   * @param font_matrix font space to user space transformation matrix for the
-   * font. In the simplest case of a N point font, this matrix is just a scale
-   * by N, but it can also be used to shear the font or stretch it unequally
-   * along the two axes. See Context::set_font_matrix().
-   * @param ctm user to device transformation matrix with which the font will be
-   * used.
-   * @param options: options to use when getting metrics for the font and
-   * rendering with it.
-   */
-  static RefPtr<ScaledFont> create(FontFace& font_face, const Matrix& font_matrix,
-      const Matrix& ctm, const FontOptions& options);
-
-  /** Gets the metrics for a ScaledFont */
-  void extents(FontExtents& extents) const;
-
-  /** Gets the extents for a string of text. The extents describe a user-space
-   * rectangle that encloses the "inked" portion of the text drawn at the origin
-   * (0,0) (as it would be drawn by Context::show_text() if the cairo graphics
-   * state were set to the same font_face, font_matrix, ctm, and font_options as
-   * the ScaledFont object).  Additionally, the x_advance and y_advance values
-   * indicate the amount by which the current point would be advanced by
-   * Context::show_text().
-   *
-   * Note that whitespace characters do not directly contribute to the size of
-   * the rectangle (extents.width and extents.height). They do contribute
-   * indirectly by changing the position of non-whitespace characters. In
-   * particular, trailing whitespace characters are likely to not affect the
-   * size of the rectangle, though they will affect the x_advance and y_advance
-   * values.
-   *
-   * @param utf8  a string of text, encoded in UTF-8
-   * @param extents Returns the extents of the given string
-   *
-   * @since 1.2
-   */
-  void text_extents(const std::string& utf8, TextExtents& extents) const;
-
-  /** Gets the extents for an array of glyphs. The extents describe a user-space
-   * rectangle that encloses the "inked" portion of the glyphs, (as they would
-   * be drawn by Context::show_glyphs() if the cairo graphics state were set to the
-   * same font_face, font_matrix, ctm, and font_options as the ScaledFont
-   * object).  Additionally, the x_advance and y_advance values indicate the
-   * amount by which the current point would be advanced by Context::show_glyphs().
-   *
-   * Note that whitespace glyphs do not contribute to the size of the rectangle
-   * (extents.width and extents.height).
-   *
-   * @param glyphs A vector of glyphs to calculate the extents of
-   * @param extents Returns the extents for the array of glyphs
-   **/
-  void glyph_extents(const std::vector<Glyph>& glyphs, TextExtents& extents);
-
-  /** The FontFace with which this ScaledFont was created.
-   * @since 1.2
-   */
-  RefPtr<FontFace> get_font_face() const;
-
-  /** Gets the FontOptions with which the ScaledFont was created.
-   * @since 1.2
-   */
-  void get_font_options(FontOptions& options) const;
-
-  /** Gets the font matrix with which the ScaledFont was created.
-   * @since 1.2
-   */
-  void get_font_matrix(Matrix& font_matrix) const;
-
-  /** Gets the CTM with which the ScaledFont was created.
-   * @since 1.2
-   */
-  void get_ctm(Matrix& ctm) const;
-
-  /** Gets the type of scaled Font
-   * @since 1.2
-   */
-  FontType get_type() const;
-
-  protected:
-  /** The underlying C cairo object that is wrapped by this ScaledFont */
-  cobject* m_cobject;
-};
-
-}
-
-#endif // __CAIROMM_SCALEDFONT_H
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/surface.cc b/libs/cairomm/cairomm/surface.cc
deleted file mode 100644
index 90cc303f05..0000000000
--- a/libs/cairomm/cairomm/surface.cc
+++ /dev/null
@@ -1,382 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/surface.h>
-#include <cairomm/private.h>
-
-namespace Cairo
-{
-
-Surface::Surface(cairo_surface_t* cobject, bool has_reference)
-: m_cobject(0)
-{
-  if(has_reference)
-    m_cobject = cobject;
-  else
-    m_cobject = cairo_surface_reference(cobject);
-}
-
-Surface::~Surface()
-{
-  if(m_cobject)
-    cairo_surface_destroy(m_cobject);
-}
-
-void Surface::finish()
-{
-  cairo_surface_finish(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Surface::get_font_options(FontOptions& options) const
-{
-  cairo_font_options_t* cfontoptions = cairo_font_options_create();
-  cairo_surface_get_font_options(m_cobject, cfontoptions);
-  options = FontOptions(cfontoptions);
-  cairo_font_options_destroy(cfontoptions);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Surface::flush()
-{
-  cairo_surface_flush(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Surface::mark_dirty()
-{
-  cairo_surface_mark_dirty(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Surface::mark_dirty(int x, int y, int width, int height)
-{
-  cairo_surface_mark_dirty_rectangle(m_cobject, x, y, width, height);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Surface::set_device_offset(double x_offset, double y_offset)
-{
-  cairo_surface_set_device_offset(m_cobject, x_offset, y_offset);
-  check_object_status_and_throw_exception(*this);
-}
-
-void Surface::get_device_offset(double& x_offset, double& y_offset) const
-{
-  cairo_surface_get_device_offset(const_cast<cobject*>(m_cobject), &x_offset, &y_offset);
-}
-
-void Surface::set_fallback_resolution(double x_pixels_per_inch, double y_pixels_per_inch)
-{
-  cairo_surface_set_fallback_resolution(m_cobject, x_pixels_per_inch, y_pixels_per_inch);
-  check_object_status_and_throw_exception(*this);
-}
-
-SurfaceType Surface::get_type() const
-{
-  cairo_surface_type_t surface_type = cairo_surface_get_type(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return static_cast<SurfaceType>(surface_type);
-}
-
-#ifdef CAIRO_HAS_PNG_FUNCTIONS
-void Surface::write_to_png(const std::string& filename)
-{
-  ErrorStatus status = cairo_surface_write_to_png(m_cobject, filename.c_str());
-  check_status_and_throw_exception(status);
-}
-
-void Surface::write_to_png(cairo_write_func_t write_func, void *closure)
-{
-  ErrorStatus status = cairo_surface_write_to_png_stream(m_cobject, write_func, closure);
-  check_status_and_throw_exception(status);
-}
-#endif
-
-void Surface::reference() const
-{
-  cairo_surface_reference(m_cobject);
-}
-
-void Surface::unreference() const
-{
-  cairo_surface_destroy(m_cobject);
-}
-
-RefPtr<Surface> Surface::create(const RefPtr<Surface> other, Content content, int width, int height)
-{
-  cairo_surface_t* cobject = cairo_surface_create_similar(other->m_cobject, (cairo_content_t)content, width, height);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<Surface>(new Surface(cobject, true /* has reference */));
-}
-
-
-
-ImageSurface::ImageSurface(cairo_surface_t* cobject, bool has_reference)
-: Surface(cobject, has_reference)
-{ }
-
-ImageSurface::~ImageSurface()
-{
-  // surface is destroyed in base class
-}
-
-RefPtr<ImageSurface> ImageSurface::create(Format format, int width, int height)
-{
-  cairo_surface_t* cobject = cairo_image_surface_create((cairo_format_t)format, width, height);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
-}
-
-RefPtr<ImageSurface> ImageSurface::create(unsigned char* data, Format format, int width, int height, int stride)
-{
-  cairo_surface_t* cobject = cairo_image_surface_create_for_data(data, (cairo_format_t)format, width, height, stride);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
-}
-
-#ifdef CAIRO_HAS_PNG_FUNCTIONS
-
-RefPtr<ImageSurface> ImageSurface::create_from_png(std::string filename)
-{
-  cairo_surface_t* cobject = cairo_image_surface_create_from_png(filename.c_str());
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
-}
-
-RefPtr<ImageSurface> ImageSurface::create_from_png(cairo_read_func_t read_func, void *closure)
-{
-  cairo_surface_t* cobject = cairo_image_surface_create_from_png_stream(read_func, closure);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<ImageSurface>(new ImageSurface(cobject, true /* has reference */));
-}
-
-#endif // CAIRO_HAS_PNG_FUNCTIONS
-
-int ImageSurface::get_width() const
-{
-  const int result = cairo_image_surface_get_width(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-int ImageSurface::get_height() const
-{
-  const int result = cairo_image_surface_get_height(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return result;
-}
-
-unsigned char* ImageSurface::get_data()
-{
-  return cairo_image_surface_get_data(m_cobject);
-}
-
-const unsigned char* ImageSurface::get_data() const
-{
-  return cairo_image_surface_get_data(m_cobject);
-}
-
-Format ImageSurface::get_format() const
-{
-  return static_cast<Format>(cairo_image_surface_get_format(m_cobject));
-}
-
-int ImageSurface::get_stride() const
-{
-  return cairo_image_surface_get_stride(m_cobject);
-}
-
-
-/*******************************************************************************
- * THE FOLLOWING SURFACE TYPES ARE EXPERIMENTAL AND NOT FULLY SUPPORTED
- ******************************************************************************/
-
-#ifdef CAIRO_HAS_PDF_SURFACE
-
-PdfSurface::PdfSurface(cairo_surface_t* cobject, bool has_reference) :
-    Surface(cobject, has_reference)
-{}
-
-PdfSurface::~PdfSurface()
-{
-  // surface is destroyed in base class
-}
-
-RefPtr<PdfSurface> PdfSurface::create(std::string filename, double width_in_points, double height_in_points)
-{
-  cairo_surface_t* cobject = cairo_pdf_surface_create(filename.c_str(), width_in_points, height_in_points);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<PdfSurface>(new PdfSurface(cobject, true /* has reference */));
-}
-
-RefPtr<PdfSurface> PdfSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)
-{
-  cairo_surface_t* cobject = cairo_pdf_surface_create_for_stream(write_func, closure, width_in_points, height_in_points);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<PdfSurface>(new PdfSurface(cobject, true /* has reference */));
-}
-
-void PdfSurface::set_size(double width_in_points, double height_in_points)
-{
-  cairo_pdf_surface_set_size(m_cobject, width_in_points, height_in_points);
-  check_object_status_and_throw_exception(*this);
-}
-
-#endif // CAIRO_HAS_PDF_SURFACE
-
-
-
-
-#ifdef CAIRO_HAS_PS_SURFACE
-
-PsSurface::PsSurface(cairo_surface_t* cobject, bool has_reference) :
-    Surface(cobject, has_reference)
-{}
-
-PsSurface::~PsSurface()
-{
-  // surface is destroyed in base class
-}
-
-RefPtr<PsSurface> PsSurface::create(std::string filename, double width_in_points, double height_in_points)
-{
-  cairo_surface_t* cobject = cairo_ps_surface_create(filename.c_str(), width_in_points, height_in_points);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<PsSurface>(new PsSurface(cobject, true /* has reference */));
-}
-
-RefPtr<PsSurface> PsSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)
-{
-  cairo_surface_t* cobject = cairo_ps_surface_create_for_stream(write_func, closure, width_in_points, height_in_points);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<PsSurface>(new PsSurface(cobject, true /* has reference */));
-}
-
-void PsSurface::set_size(double width_in_points, double height_in_points)
-{
-  cairo_ps_surface_set_size(m_cobject, width_in_points, height_in_points);
-  check_object_status_and_throw_exception(*this);
-}
-
-
-void PsSurface::dsc_comment(std::string comment)
-{
-  cairo_ps_surface_dsc_comment(m_cobject, comment.c_str());
-  check_object_status_and_throw_exception(*this);
-}
-
-void PsSurface::dsc_begin_setup()
-{
-  cairo_ps_surface_dsc_begin_setup(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-void PsSurface::dsc_begin_page_setup()
-{
-  cairo_ps_surface_dsc_begin_page_setup(m_cobject);
-  check_object_status_and_throw_exception(*this);
-}
-
-
-#endif // CAIRO_HAS_PS_SURFACE
-
-
-
-
-#ifdef CAIRO_HAS_SVG_SURFACE
-
-SvgSurface::SvgSurface(cairo_surface_t* cobject, bool has_reference) :
-    Surface(cobject, has_reference)
-{}
-
-SvgSurface::~SvgSurface()
-{
-  // surface is destroyed in base class
-}
-
-RefPtr<SvgSurface> SvgSurface::create(std::string filename, double width_in_points, double height_in_points)
-{
-  cairo_surface_t* cobject = cairo_svg_surface_create(filename.c_str(), width_in_points, height_in_points);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<SvgSurface>(new SvgSurface(cobject, true /* has reference */));
-}
-
-RefPtr<SvgSurface> SvgSurface::create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points)
-{
-  cairo_surface_t* cobject = cairo_svg_surface_create_for_stream(write_func, closure, width_in_points, height_in_points);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<SvgSurface>(new SvgSurface(cobject, true /* has reference */));
-}
-
-void SvgSurface::restrict_to_version(SvgVersion version)
-{
-  cairo_svg_surface_restrict_to_version(m_cobject, static_cast<cairo_svg_version_t>(version));
-  check_object_status_and_throw_exception(*this);
-}
-
-const std::vector<SvgVersion> SvgSurface::get_versions()
-{
-  cairo_svg_version_t const *versions;
-  int num_versions;
-  cairo_svg_get_versions(&versions, &num_versions);
-
-  // Just copy the version array out into a std::vector.  This is a rarely used
-  // function and the array of versions is going to be very small, so there's no
-  // real performance hit.
-  std::vector<SvgVersion> vec;
-  for (int i = 0; i < num_versions; ++i)
-  {
-    vec.push_back(static_cast<SvgVersion>(versions[i]));
-  }
-  return vec;
-}
-
-std::string SvgSurface::version_to_string(SvgVersion version)
-{
-  return std::string(cairo_svg_version_to_string(static_cast<cairo_svg_version_t>(version)));
-}
-
-#endif // CAIRO_HAS_SVG_SURFACE
-
-
-
-
-#ifdef CAIRO_HAS_GLITZ_SURFACE
-
-GlitzSurface::GlitzSurface(cairo_surface_t* cobject, bool has_reference)
-: Surface(cobject, has_reference)
-{ }
-
-GlitzSurface::~GlitzSurface()
-{
-  // surface is destroyed in base class
-}
-
-RefPtr<GlitzSurface> GlitzSurface::create(glitz_surface_t *surface)
-{
-  cairo_surface_t* cobject = cairo_glitz_surface_create(surface);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<GlitzSurface>(new GlitzSurface(cobject, true /* has reference */));
-}
-
-#endif // CAIRO_HAS_GLITZ_SURFACE
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/surface.h b/libs/cairomm/cairomm/surface.h
deleted file mode 100644
index 001f754a79..0000000000
--- a/libs/cairomm/cairomm/surface.h
+++ /dev/null
@@ -1,631 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_SURFACE_H
-#define __CAIROMM_SURFACE_H
-
-#include <string>
-#include <vector>
-#include <cairomm/enums.h>
-#include <cairomm/exception.h>
-#include <cairomm/fontoptions.h>
-#include <cairomm/refptr.h>
-
-//See xlib_surface.h for XlibSurface.
-//See win32_surface.h for Win32Surface.
-
-#ifdef CAIRO_HAS_PDF_SURFACE
-#include <cairo-pdf.h>
-#endif // CAIRO_HAS_PDF_SURFACE
-#ifdef CAIRO_HAS_PS_SURFACE
-#include <cairo-ps.h>
-#endif // CAIRO_HAS_PS_SURFACE
-#ifdef CAIRO_HAS_SVG_SURFACE
-#include <cairo-svg.h>
-#endif // CAIRO_HAS_SVG_SURFACE
-
-// Experimental surfaces
-#ifdef CAIRO_HAS_GLITZ_SURFACE
-#include <cairo-glitz.h>
-#endif // CAIRO_HAS_GLITZ_SURFACE
-
-
-namespace Cairo
-{
-
-/** A cairo surface represents an image, either as the destination of a drawing
- * operation or as source when drawing onto another surface. There are
- * different subtypes of cairo surface for different drawing backends.  This
- * class is a base class for all subtypes and should not be used directly
- *
- * Surfaces are reference-counted objects that should be used via Cairo::RefPtr. 
- */
-class Surface
-{
-public:
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit Surface(cairo_surface_t* cobject, bool has_reference = false);
-
-  virtual ~Surface();
-
-  /** Retrieves the default font rendering options for the surface. This allows
-   * display surfaces to report the correct subpixel order for rendering on
-   * them, print surfaces to disable hinting of metrics and so forth. The
-   * result can then be used with cairo_scaled_font_create().
-   *
-   * @param options 	a FontOptions object into which to store the retrieved
-   * options. All existing values are overwritten
-   */
-  void get_font_options(FontOptions& options) const;
-
-  /** This function finishes the surface and drops all references to external
-   * resources. For example, for the Xlib backend it means that cairo will no
-   * longer access the drawable, which can be freed. After calling
-   * finish() the only valid operations on a surface are getting and setting
-   * user data and referencing and destroying it. Further drawing to the
-   * surface will not affect the surface but will instead trigger a
-   * CAIRO_STATUS_SURFACE_FINISHED error.
-   *
-   * When the Surface is destroyed, cairo will call finish() if it hasn't been
-   * called already, before freeing the resources associated with the Surface.
-   */
-  void finish();
-
-  /** Do any pending drawing for the surface and also restore any temporary
-   * modifications cairo has made to the surface's state. This function must
-   * be called before switching from drawing on the surface with cairo to
-   * drawing on it directly with native APIs. If the surface doesn't support
-   * direct access, then this function does nothing.
-   */
-  void flush();
-
-  /** Tells cairo to consider the data buffer dirty.
-   *
-   * In particular, if you've created an ImageSurface with a data buffer that
-   * you've allocated yourself and you draw to that data buffer using means
-   * other than cairo, you must call mark_dirty() before doing any additional
-   * drawing to that surface with cairo.
-   *
-   * Note that if you do draw to the Surface outside of cairo, you must call
-   * flush() before doing the drawing.
-   */
-  void mark_dirty();
-
-  /** Marks a rectangular area of the given surface dirty.
-   *
-   * @param x 	 X coordinate of dirty rectangle
-   * @param y 	Y coordinate of dirty rectangle
-   * @param width 	width of dirty rectangle
-   * @param height 	height of dirty rectangle
-   */
-  void mark_dirty(int x, int y, int width, int height);
-
-  /** Sets an offset that is added to the device coordinates determined by the
-   * CTM when drawing to surface. One use case for this function is when we
-   * want to create a Surface that redirects drawing for a portion of
-   * an onscreen surface to an offscreen surface in a way that is completely
-   * invisible to the user of the cairo API. Setting a transformation via
-   * cairo_translate() isn't sufficient to do this, since functions like
-   * Cairo::Context::device_to_user() will expose the hidden offset.
-   *
-   * Note that the offset only affects drawing to the surface, not using the
-   * surface in a surface pattern.
-   *
-   * @param x_offset 	the offset in the X direction, in device units
-   * @param y_offset 	the offset in the Y direction, in device units
-   */
-  void set_device_offset(double x_offset, double y_offset);
-
-  /** Returns a previous device offset set by set_device_offset().
-   */
-  void get_device_offset(double& x_offset, double& y_offset) const;
-
-  /** Sets the fallback resolution of the image in dots per inch
-   *
-   * @param x_pixels_per_inch   Pixels per inch in the x direction
-   * @param y_pixels_per_inch   Pixels per inch in the y direction
-   */
-  void set_fallback_resolution(double x_pixels_per_inch, double y_pixels_per_inch);
-
-  SurfaceType get_type() const;
-
-#ifdef CAIRO_HAS_PNG_FUNCTIONS
-
-  /** Writes the contents of surface to a new file filename as a PNG image.
-   *
-   * @note For this function to be available, cairo must have been compiled
-   * with PNG support
-   *
-   * @param filename	the name of a file to write to
-   */
-  void write_to_png(const std::string& filename);
-
-  /** Writes the Surface to the write function.
-   *
-   * @note For this function to be available, cairo must have been compiled
-   * with PNG support
-   *
-   * @param write_func  The function to be called when the backend needs to
-   * write data to an output stream
-   * @param closure	closure data for the write function
-   */
-  void write_to_png(cairo_write_func_t write_func, void *closure); //TODO: Use a sigc::slot?
-
-#endif // CAIRO_HAS_PNG_FUNCTIONS
-
-
-  /** The underlying C cairo surface type
-   */
-  typedef cairo_surface_t cobject;
-  /** Provides acces to the underlying C cairo surface
-   */
-  inline cobject* cobj() { return m_cobject; }
-  /** Provides acces to the underlying C cairo surface
-   */
-  inline const cobject* cobj() const { return m_cobject; }
-
-  #ifndef DOXYGEN_IGNORE_THIS
-  ///For use only by the cairomm implementation.
-  inline ErrorStatus get_status() const
-  { return cairo_surface_status(const_cast<cairo_surface_t*>(cobj())); }
-
-  void reference() const;
-  void unreference() const;
-  #endif //DOXYGEN_IGNORE_THIS
-
-  /** Create a new surface that is as compatible as possible with an existing
-   * surface. The new surface will use the same backend as other unless that is
-   * not possible for some reason.
-   *
-   * @param other 	an existing surface used to select the backend of the new surface
-   * @param content 	the content for the new surface
-   * @param width 	width of the new surface, (in device-space units)
-   * @param height 	height of the new surface (in device-space units)
-   * @return 	a RefPtr to the newly allocated surface.
-   */
-  static RefPtr<Surface> create(const RefPtr<Surface> other, Content content, int width, int height);
-
-protected:
-  /** The underlying C cairo surface type that is wrapped by this Surface
-   */
-  cobject* m_cobject;
-};
-
-
-/** Image surfaces provide the ability to render to memory buffers either
- * allocated by cairo or by the calling code. The supported image formats are
- * those defined in Cairo::Format
- *
- * An ImageSurface is the most generic type of Surface and the only one that is
- * available by default.  You can either create an ImageSurface whose data is
- * managed by Cairo, or you can create an ImageSurface with a data buffer that
- * you allocated yourself so that you can have full access to the data.  
- *
- * When you create an ImageSurface with your own data buffer, you are free to
- * examine the results at any point and do whatever you want with it.  Note that
- * if you modify anything and later want to continue to draw to the surface
- * with cairo, you must let cairo know via Cairo::Surface::mark_dirty() 
- *
- * Note that like all surfaces, an ImageSurface is a reference-counted object that should be used via Cairo::RefPtr.
- */
-class ImageSurface : public Surface
-{
-protected:
-  //TODO?: Surface(cairo_surface_t *target);
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   * @param cobject The C instance.
-   * @param has_reference Whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit ImageSurface(cairo_surface_t* cobject, bool has_reference = false);
-
-  virtual ~ImageSurface();
-
-  /** Gets the width of the ImageSurface in pixels
-   */
-  int get_width() const;
-
-  /** Gets the height of the ImageSurface in pixels
-   */
-  int get_height() const;
-
-  /**
-   * Get a pointer to the data of the image surface, for direct
-   * inspection or modification.
-   *
-   * Return value: a pointer to the image data of this surface or NULL
-   * if @surface is not an image surface.
-   */
-  unsigned char* get_data();
-  const unsigned char* get_data() const;
-
-  /** gets the format of the surface
-   */
-  Format get_format() const;
-
-  /**
-   * Return value: the stride of the image surface in bytes (or 0 if
-   * @surface is not an image surface). The stride is the distance in
-   * bytes from the beginning of one row of the image data to the
-   * beginning of the next row.
-   */
-  int get_stride() const;
-
-
-  /** Creates an image surface of the specified format and dimensions. The
-   * initial contents of the surface is undefined; you must explicitely clear
-   * the buffer, using, for example, Cairo::Context::rectangle() and
-   * Cairo::Context::fill() if you want it cleared.
-   *
-   * Use this function to create the surface if you don't need access to the
-   * internal data and want cairo to manage it for you.  Since you don't have
-   * access to the internal data, the resulting surface can only be saved to a
-   * PNG image file (if cairo has been compiled with PNG support) or as a
-   * source surface (see Cairo::SurfacePattern).
-   *
-   * @param format 	format of pixels in the surface to create
-   * @param width 	width of the surface, in pixels
-   * @param height 	height of the surface, in pixels
-   * @return 	a RefPtr to the newly created surface.
-   */
-  static RefPtr<ImageSurface> create(Format format, int width, int height);
-
-  /** Creates an image surface for the provided pixel data. The output buffer
-   * must be kept around until the Surface is destroyed or finish() is called
-   * on the surface. The initial contents of buffer will be used as the inital
-   * image contents; you must explicitely clear the buffer, using, for example,
-   * Cairo::Context::rectangle() and Cairo::Context::fill() if you want it
-   * cleared.
-   *
-   * If you want to be able to manually manipulate or extract the data after
-   * drawing to the surface with Cairo, you should use this function to create
-   * the Surface.  Since you own the internal data, you can do anything you
-   * want with it.
-   *
-   * @param data	a pointer to a buffer supplied by the application in which
-   * to write contents.
-   * @param format	the format of pixels in the buffer
-   * @param width	the width of the image to be stored in the buffer
-   * @param height	the height of the image to be stored in the buffer
-   * @param stride	the number of bytes between the start of rows in the
-   * buffer. Having this be specified separate from width allows for padding at
-   * the end of rows, or for writing to a subportion of a larger image.
-   * @return	a RefPtr to the newly created surface.
-   */
-  static RefPtr<ImageSurface> create(unsigned char* data, Format format, int width, int height, int stride);
-
-#ifdef CAIRO_HAS_PNG_FUNCTIONS
-
-  /** Creates a new image surface and initializes the contents to the given PNG
-   * file.  
-   *
-   * @note For this function to be available, cairo must have been compiled
-   * with PNG support.
-   *
-   * @param filename	name of PNG file to load
-   * @return	a RefPtr to the new cairo_surface_t initialized with the
-   * contents of the PNG image file.
-   */
-  static RefPtr<ImageSurface> create_from_png(std::string filename);
-
-  /** Creates a new image surface from PNG data read incrementally via the
-   * read_func function.  
-   *
-   * @note For this function to be available, cairo must have been compiled
-   * with PNG support.
-   *
-   * @param read_func	function called to read the data of the file
-   * @param closure	data to pass to read_func.
-   * @return	a RefPtr to the new cairo_surface_t initialized with the
-   * contents of the PNG image file.
-   */
-  static RefPtr<ImageSurface> create_from_png(cairo_read_func_t read_func, void *closure);
-
-#endif // CAIRO_HAS_PNG_FUNCTIONS
-
-};
-
-
-#ifdef CAIRO_HAS_PDF_SURFACE
-
-/** A PdfSurface provides a way to render PDF documents from cairo.  This
- * surface is not rendered to the screen but instead renders the drawing to a
- * PDF file on disk.
- *
- * @note For this Surface to be available, cairo must have been compiled with
- * PDF support
- */
-class PdfSurface : public Surface
-{
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit PdfSurface(cairo_surface_t* cobject, bool has_reference = false);
-  virtual ~PdfSurface();
-
-  /** Creates a PdfSurface with a specified dimensions that will be saved as
-   * the given filename
-   *
-   * @param filename    The name of the PDF file to save the surface to
-   * @param width_in_points   The width of the PDF document in points
-   * @param height_in_points   The height of the PDF document in points
-   */
-  static RefPtr<PdfSurface> create(std::string filename, double width_in_points, double height_in_points);
-
-  /** Creates a PdfSurface with a specified dimensions that will be written to
-   * the given write function instead of saved directly to disk
-   *
-   * @param write_func  The function to be called when the backend needs to
-   * write data to an output stream
-   * @param closure     closure data for the write function
-   * @param width_in_points   The width of the PDF document in points
-   * @param height_in_points   The height of the PDF document in points
-   */
-  static RefPtr<PdfSurface> create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points);
-
-/**
- * Changes the size of a PDF surface for the current (and subsequent) pages.
- *
- * This function should only be called before any drawing operations have been
- * performed on the current page. The simplest way to do this is to call this
- * function immediately after creating the surface or immediately after
- * completing a page with either Context::show_page() or Context::copy_page().
- *
- * @param width_in_points new surface width, in points (1 point == 1/72.0 inch)
- * @param height_in_points new surface height, in points (1 point == 1/72.0 inch)
- **/
-  void set_size(double width_in_points, double height_in_points);
-
-};
-
-#endif  // CAIRO_HAS_PDF_SURFACE
-
-
-#ifdef CAIRO_HAS_PS_SURFACE
-
-/** A PsSurface provides a way to render PostScript documents from cairo.  This
- * surface is not rendered to the screen but instead renders the drawing to a
- * PostScript file on disk.
- *
- * @note For this Surface to be available, cairo must have been compiled with
- * PostScript support
- */
-class PsSurface : public Surface
-{
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit PsSurface(cairo_surface_t* cobject, bool has_reference = false);
-  virtual ~PsSurface();
-
-  /** Creates a PsSurface with a specified dimensions that will be saved as the
-   * given filename
-   *
-   * @param filename    The name of the PostScript file to save the surface to
-   * @param width_in_points   The width of the PostScript document in points
-   * @param height_in_points   The height of the PostScript document in points
-   */
-  static RefPtr<PsSurface> create(std::string filename, double width_in_points, double height_in_points);
-
-  /** Creates a PsSurface with a specified dimensions that will be written to
-   * the given write function instead of saved directly to disk
-   *
-   * @param write_func  The function to be called when the backend needs to
-   * write data to an output stream
-   * @param closure     closure data for the write function
-   * @param width_in_points   The width of the PostScript document in points
-   * @param height_in_points   The height of the PostScript document in points
-   */
-  static RefPtr<PsSurface> create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points);
-
-  /**
-   * Changes the size of a PostScript surface for the current (and
-   * subsequent) pages.
-   *
-   * This function should only be called before any drawing operations have been
-   * performed on the current page. The simplest way to do this is to call this
-   * function immediately after creating the surface or immediately after
-   * completing a page with either Context::show_page() or Context::copy_page().
-   *
-   * @param width_in_points new surface width, in points (1 point == 1/72.0 inch)
-   * @param height_in_points new surface height, in points (1 point == 1/72.0 inch)
-   */
-  void set_size(double width_in_points, double height_in_points);
-
-  /** Emit a comment into the PostScript output for the given surface.  See the
-   * cairo reference documentation for more information.
-   *
-   * @param comment a comment string to be emitted into the PostScript output
-   */
-  void dsc_comment(std::string comment);
-
-  /**
-   * This function indicates that subsequent calls to dsc_comment() should direct
-   * comments to the Setup section of the PostScript output.
-   *
-   * This function should be called at most once per surface, and must be called
-   * before any call to dsc_begin_page_setup() and before any drawing is performed
-   * to the surface.
-   */
-  void dsc_begin_setup();
-
-  /** This function indicates that subsequent calls to dsc_comment() should
-   * direct comments to the PageSetup section of the PostScript output.
-   *
-   * This function call is only needed for the first page of a surface. It
-   * should be called after any call to dsc_begin_setup() and before any drawing
-   * is performed to the surface.
-   */
-  void dsc_begin_page_setup();
-
-};
-
-#endif // CAIRO_HAS_PS_SURFACE
-
-
-#ifdef CAIRO_HAS_SVG_SURFACE
-
-typedef enum
-{
-  SVG_VERSION_1_1 = CAIRO_SVG_VERSION_1_1,
-  SVG_VERSION_1_2 = CAIRO_SVG_VERSION_1_2
-} SvgVersion;
-
-/** A SvgSurface provides a way to render Scalable Vector Graphics (SVG) images
- * from cairo.  This surface is not rendered to the screen but instead renders
- * the drawing to an SVG file on disk.
- *
- * @note For this Surface to be available, cairo must have been compiled with
- * SVG support
- */
-class SvgSurface : public Surface
-{
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit SvgSurface(cairo_surface_t* cobject, bool has_reference = false);
-  virtual ~SvgSurface();
-
-
-  /** Creates a SvgSurface with a specified dimensions that will be saved as the
-   * given filename
-   *
-   * @param filename    The name of the SVG file to save the surface to
-   * @param width_in_points   The width of the SVG document in points
-   * @param height_in_points   The height of the SVG document in points
-   */
-  static RefPtr<SvgSurface> create(std::string filename, double width_in_points, double height_in_points);
-
-  /** Creates a SvgSurface with a specified dimensions that will be written to
-   * the given write function instead of saved directly to disk
-   *
-   * @param write_func  The function to be called when the backend needs to
-   * write data to an output stream
-   * @param closure     closure data for the write function
-   * @param width_in_points   The width of the SVG document in points
-   * @param height_in_points   The height of the SVG document in points
-   */
-  static RefPtr<SvgSurface> create(cairo_write_func_t write_func, void *closure, double width_in_points, double height_in_points);
-
-  /** 
-   * Restricts the generated SVG file to the given version. See get_versions()
-   * for a list of available version values that can be used here.
-   *
-   * This function should only be called before any drawing operations have been
-   * performed on the given surface. The simplest way to do this is to call this
-   * function immediately after creating the surface.
-   *
-   * @since 1.2
-   */
-  void restrict_to_version(SvgVersion version);
-
-  /** Retrieves the list of SVG versions supported by cairo. See
-   * restrict_to_version().
-   * 
-   * @since 1.2
-   */
-  static const std::vector<SvgVersion> get_versions();
-
-  /** Get the string representation of the given version id. The returned string
-   * will be empty if version isn't valid. See get_versions() for a way to get
-   * the list of valid version ids.
-   *
-   * Since: 1.2
-   */
-  static std::string version_to_string(SvgVersion version);
-};
-
-#endif // CAIRO_HAS_SVG_SURFACE
-
-
-/*******************************************************************************
- * THE FOLLOWING SURFACE TYPES ARE EXPERIMENTAL AND NOT FULLY SUPPORTED
- ******************************************************************************/
-
-#ifdef CAIRO_HAS_GLITZ_SURFACE
-
-/** A GlitzSurface provides a way to render to the X Window System using Glitz.
- * This provides a way to use OpenGL-accelerated graphics from cairo.  If you
- * want to use hardware-accelerated graphics within the X Window system, you
- * should use this Surface type.
- *
- * @note For this Surface to be available, cairo must have been compiled with
- * Glitz support
- *
- * @warning This is an experimental surface.  It is not yet marked as a fully
- * supported surface by the cairo library
- */
-class GlitzSurface : public Surface
-{
-
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit GlitzSurface(cairo_surface_t* cobject, bool has_reference = false);
-
-  virtual ~GlitzSurface();
-
-  /** Creates a new GlitzSurface
-   *
-   * @param surface  a glitz surface type
-   */
-  static RefPtr<GlitzSurface> create(glitz_surface_t *surface);
-
-};
-
-#endif // CAIRO_HAS_GLITZ_SURFACE
-
-} // namespace Cairo
-
-#endif //__CAIROMM_SURFACE_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/win32_surface.cc b/libs/cairomm/cairomm/win32_surface.cc
deleted file mode 100644
index e0e388721b..0000000000
--- a/libs/cairomm/cairomm/win32_surface.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/win32_surface.h>
-#include <cairomm/private.h>
-
-namespace Cairo
-{
-
-#ifdef CAIRO_HAS_WIN32_SURFACE
-
-Win32Surface::Win32Surface(cairo_surface_t* cobject, bool has_reference) :
-    Surface(cobject, has_reference)
-{}
-
-Win32Surface::~Win32Surface()
-{
-  // surface is destroyed in base class
-}
-
-HDC Win32Surface::get_dc() const
-{
-  return cairo_win32_surface_get_dc(m_cobject);
-}
-
-RefPtr<Win32Surface> Win32Surface::create(HDC hdc)
-{
-  cairo_surface_t* cobject = cairo_win32_surface_create(hdc);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<Win32Surface>(new Win32Surface(cobject, true /* has reference */));
-}
-
-RefPtr<Win32Surface> Win32Surface::create(Format format, int width, int height)
-{
-  cairo_surface_t* cobject = cairo_win32_surface_create_with_dib((cairo_format_t)format, width, height);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<Win32Surface>(new Win32Surface(cobject, true /* has reference */));
-}
-
-#endif // CAIRO_HAS_WIN32_SURFACE
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/win32_surface.h b/libs/cairomm/cairomm/win32_surface.h
deleted file mode 100644
index 2c9e6a7242..0000000000
--- a/libs/cairomm/cairomm/win32_surface.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_WIN32_SURFACE_H
-#define __CAIROMM_WIN32_SURFACE_H
-
-#include <cairomm/surface.h>
-#include <cairomm/enums.h>
-
-#ifdef CAIRO_HAS_WIN32_SURFACE
-#include <cairo-win32.h>
-#endif
-
-// This header is not included by cairomm.h because it requires Windows headers that 
-// tend to pollute the namespace with non-prefixed #defines and typedefs.
-// You may include it directly if you need to use this API.
-
-namespace Cairo
-{
-
-#ifdef CAIRO_HAS_WIN32_SURFACE
-
-/** A Win32Surface provides a way to render within Microsoft Windows.  If you
- * want to draw to the screen within a Microsoft Windows application, you
- * should use this Surface type.
- *
- * @note For this Surface to be available, cairo must have been compiled with
- * Win32 support
- */
-class Win32Surface : public Surface
-{
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit Win32Surface(cairo_surface_t* cobject, bool has_reference = false);
-  virtual ~Win32Surface();
-
-  /** Returns the HDC associated with this surface, or NULL if none. Also
-   * returns NULL if the surface is not a win32 surface.
-   *
-   * @return HDC or NULL if no HDC available.
-   */
-  HDC get_dc() const;
-
-  /** Creates a cairo surface that targets the given DC. The DC will be queried
-   * for its initial clip extents, and this will be used as the size of the
-   * cairo surface. Also, if the DC is a raster DC, it will be queried for its
-   * pixel format and the cairo surface format will be set appropriately.
-   *
-   * @param hdc the DC to create a surface for
-   * @return the newly created surface
-   */
-  static RefPtr<Win32Surface> create(HDC hdc);
-
-  /** Creates a device-independent-bitmap surface not associated with any
-   * particular existing surface or device context. The created bitmap will be
-   * unititialized.
-   *
-   * @param format format of pixels in the surface to create
-   * @param width width of the surface, in pixels
-   * @param height height of the surface, in pixels
-   * @return the newly created surface
-   */
-  static RefPtr<Win32Surface> create(Format format, int width, int height);
-
-};
-
-#endif // CAIRO_HAS_WIN32_SURFACE
-
-
-} // namespace Cairo
-
-#endif //__CAIROMM_WIN32_SURFACE_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/xlib_surface.cc b/libs/cairomm/cairomm/xlib_surface.cc
deleted file mode 100644
index 8320521927..0000000000
--- a/libs/cairomm/cairomm/xlib_surface.cc
+++ /dev/null
@@ -1,137 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#include <cairomm/xlib_surface.h>
-#include <cairomm/private.h>
-
-
-namespace Cairo
-{
-
-#ifdef CAIRO_HAS_XLIB_SURFACE
-
-XlibSurface::XlibSurface(cairo_surface_t* cobject, bool has_reference) :
-    Surface(cobject, has_reference)
-{}
-
-XlibSurface::~XlibSurface()
-{
-  // surface is destroyed in base class
-}
-
-RefPtr<XlibSurface> XlibSurface::create(Display* dpy, Drawable drawable, Visual* visual, int width, int height)
-{
-  cairo_surface_t* cobject = cairo_xlib_surface_create(dpy, drawable, visual, width, height);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<XlibSurface>(new XlibSurface(cobject, true /* has reference */));
-}
-
-RefPtr<XlibSurface> XlibSurface::create(Display* dpy, Pixmap bitmap, Screen* screen, int width, int height)
-{
-  cairo_surface_t* cobject = cairo_xlib_surface_create_for_bitmap(dpy, bitmap, screen, width, height);
-  check_status_and_throw_exception(cairo_surface_status(cobject));
-  return RefPtr<XlibSurface>(new XlibSurface(cobject, true /* has reference */));
-}
-
-void XlibSurface::set_size(int width, int height)
-{
-  cairo_xlib_surface_set_size(m_cobject, width, height);
-  check_object_status_and_throw_exception(*this);
-}
-
-void XlibSurface::set_drawable(Drawable drawable, int width, int height)
-{
-  cairo_xlib_surface_set_drawable(m_cobject, drawable, width, height);
-  check_object_status_and_throw_exception(*this);
-}
-
-Drawable XlibSurface::get_drawable() const
-{
-  Drawable drawable = cairo_xlib_surface_get_drawable(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return drawable;
-}
-
-const Display* XlibSurface::get_display() const
-{
-  const Display* dpy = cairo_xlib_surface_get_display(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return dpy;
-}
-
-Display* XlibSurface::get_display()
-{
-  Display* dpy = cairo_xlib_surface_get_display(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return dpy;
-}
-
-Screen* XlibSurface::get_screen()
-{
-  Screen* screen = cairo_xlib_surface_get_screen(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return screen;
-}
-
-const Screen* XlibSurface::get_screen() const
-{
-  const Screen* screen = cairo_xlib_surface_get_screen(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return screen;
-}
-
-Visual* XlibSurface::get_visual()
-{
-  Visual* visual = cairo_xlib_surface_get_visual(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return visual;
-}
-
-const Visual* XlibSurface::get_visual() const
-{
-  const Visual* visual = cairo_xlib_surface_get_visual(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return visual;
-}
-
-int XlibSurface::get_depth() const
-{
-  int depth = cairo_xlib_surface_get_depth(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return depth;
-}
-
-int XlibSurface::get_height() const
-{
-  int h = cairo_xlib_surface_get_height(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return h;
-}
-
-int XlibSurface::get_width() const
-{
-  int w = cairo_xlib_surface_get_width(m_cobject);
-  check_object_status_and_throw_exception(*this);
-  return w;
-}
-
-#endif // CAIRO_HAS_XLIB_SURFACE
-
-} //namespace Cairo
-
-// vim: ts=2 sw=2 et
diff --git a/libs/cairomm/cairomm/xlib_surface.h b/libs/cairomm/cairomm/xlib_surface.h
deleted file mode 100644
index cddd8806ac..0000000000
--- a/libs/cairomm/cairomm/xlib_surface.h
+++ /dev/null
@@ -1,148 +0,0 @@
-/* Copyright (C) 2005 The cairomm 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., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- */
-
-#ifndef __CAIROMM_XLIB_SURFACE_H
-#define __CAIROMM_XLIB_SURFACE_H
-
-#include <cairomm/surface.h>
-
-// This header is not included by cairomm.h because it requires X headers that 
-// tend to pollute the namespace with non-prefixed #defines and typedefs.
-// You may include it directly if you need to use this API.
-
-#ifdef CAIRO_HAS_XLIB_SURFACE
-#include <cairo-xlib.h> //Needed for the X11 "Display" struct (which pollutes the namespace because it has no prefix.)
-#endif
-
-
-namespace Cairo
-{
-
-#ifdef CAIRO_HAS_XLIB_SURFACE
-
-/** An XlibSurface provides a way to render to the X Window System using XLib.
- * If you want to draw to the screen within an application that uses the X
- * Window system, you should use this Surface type.
- *
- * @note For this surface to be availabe, cairo must have been compiled with
- * support for XLib Surfaces
- */
-class XlibSurface : public Surface
-{
-public:
-
-  /** Create a C++ wrapper for the C instance. This C++ instance should then be
-   * given to a RefPtr.
-   *
-   * @param cobject The C instance.
-   * @param has_reference whether we already have a reference. Otherwise, the
-   * constructor will take an extra reference.
-   */
-  explicit XlibSurface(cairo_surface_t* cobject, bool has_reference = false);
-  virtual ~XlibSurface();
-
-  /** Creates an Xlib surface that draws to the given drawable. The way that
-   * colors are represented in the drawable is specified by the provided
-   * visual.
-   *
-   * @note If drawable is a Window, then the function
-   * cairo_xlib_surface_set_size must be called whenever the size of the window
-   * changes.
-   *
-   * @param dpy	an X Display
-   * @param drawable	an X Drawable, (a Pixmap or a Window)
-   * @param visual	the visual to use for drawing to drawable. The depth of the visual must match the depth of the drawable. Currently, only TrueColor visuals are fully supported.
-   * @param width	the current width of drawable.
-   * @param height	the current height of drawable.
-   * @return	A RefPtr to the newly created surface
-   */
-  static RefPtr<XlibSurface> create(Display* dpy, Drawable drawable, Visual* visual, int width, int height);
-
-  /** Creates an Xlib surface that draws to the given bitmap. This will be
-   * drawn to as a CAIRO_FORMAT_A1 object.
-   *
-   * @param dpy	an X Display
-   * @param bitmap	an X Drawable, (a depth-1 Pixmap)
-   * @param screen	the X Screen associated with bitmap
-   * @param width	the current width of bitmap.
-   * @param height	the current height of bitmap.
-   * @return	A RefPtr to the newly created surface
-   */
-  static RefPtr<XlibSurface> create(Display *dpy, Pixmap bitmap, Screen *screen, int width, int height);
-
-  /** Informs cairo of the new size of the X Drawable underlying the surface.
-   * For a surface created for a Window (rather than a Pixmap), this function
-   * must be called each time the size of the window changes. (For a subwindow,
-   * you are normally resizing the window yourself, but for a toplevel window,
-   * it is necessary to listen for ConfigureNotify events.)
-   *
-   * A Pixmap can never change size, so it is never necessary to call this
-   * function on a surface created for a Pixmap.
-   *
-   * @param width	the new width of the surface
-   * @param height	the new height of the surface
-   */
-  void set_size(int width, int height);
-
-  /** Informs cairo of a new X Drawable underlying the surface. The drawable
-   * must match the display, screen and format of the existing drawable or the
-   * application will get X protocol errors and will probably terminate. No
-   * checks are done by this function to ensure this compatibility.
-   *
-   * @param drawable	the new drawable for the surface
-   * @param width	the width of the new drawable
-   * @param height	the height of the new drawable
-   */
-  void set_drawable(Drawable drawable, int width, int height);
-
-  /** gets the Drawable object associated with this surface */
-  Drawable get_drawable() const;
-
-  /** Get the X Display for the underlying X Drawable. */
-  const Display* get_display() const;
-  /** Get the X Display for the underlying X Drawable. */
-  Display* get_display();
-
-  /** Get the X Screen for the underlying X Drawable */
-  Screen* get_screen();
-  /** Get the X Screen for the underlying X Drawable */
-  const Screen* get_screen() const;
-
-  /** Get the X Visual for the underlying X Drawable */
-  Visual* get_visual();
-  /** Get the X Visual for the underlying X Drawable */
-  const Visual* get_visual() const;
-
-  /** Get the number of bits used to represent each pixel value. */
-  int get_depth() const;
-
-  /** Get the height in pixels of the X Drawable underlying the surface */
-  int get_height() const;
-
-  /** Get the width in pixels of the X Drawable underlying the surface */
-  int get_width() const;
-
-};
-
-#endif // CAIRO_HAS_XLIB_SURFACE
-
-} // namespace Cairo
-
-#endif //__CAIROMM_XLIB_SURFACE_H
-
-// vim: ts=2 sw=2 et
diff --git a/libs/glibmm2/.cvsignore b/libs/glibmm2/.cvsignore
new file mode 100644
index 0000000000..a96ad626ea
--- /dev/null
+++ b/libs/glibmm2/.cvsignore
@@ -0,0 +1,13 @@
+Makefile
+Makefile.in
+aclocal.m4
+autom4te.cache
+config.log
+config.status
+configure
+glibmm-2.4.pc
+glibmmconfig.h
+libtool
+stamp-h1
+*.os
+*.dylib
diff --git a/libs/glibmm2/ChangeLog b/libs/glibmm2/ChangeLog
index 3e077c2c4c..0bddbef6b1 100644
--- a/libs/glibmm2/ChangeLog
+++ b/libs/glibmm2/ChangeLog
@@ -1,624 +1,3 @@
-2.12.5:
-
-Thu, 25 Jan 2007 23:13:05 +0100 Dodji Seketeli
-
-	* tools/m4/base.m4:
-	  prefix the builting mkstemp with 'm4' because otherwise,
-	  m4 1.4.8 recognizes it as a builtin macro and expands it, leading
-	  to compilation errors on some distros.
-	  This should fix #397167. Thanks to Daniel Elstner for spotting this.
-
-2.12.4:
-
-2006-11-28  Daniel Elstner  <danielk@openismus.com>
-
-	* tools/pm/GtkDefs.pm (read_defs): Allow an empty pair of
-	parentheses in the innermost match.  This fixes the problem of
-	gmmproc choking on "()" in the documentation strings.  This would
-	still break on unmatched parentheses, though.  Of course the
-	parser should just skip over quoted strings, but I wasn't able
-	to get that to work.
-	* glib/src/glib_enums.defs (GNormalizeMode): Manually fix the
-	improperly parsed value of G_NORMALIZE_NFD.  Fortunately this
-	doesn't change anything since the "#error" token was interpreted
-	as zero, which happens to be the right value.
-	* glib/src/glib_functions.defs (g_iconv): Manually convert to
-	a function definition, as it was improperly parsed as a method
-	with a zero-length name (!) of object GIConv.  This fixes the
-	annoying gmmproc warning about an allegedly unwrapped method.
-
-2006-11-27  Daniel Elstner  <danielk@openismus.com>
-
-	* tools/enum.pl (parse): Ignore whitespace in front of an enum
-	typedef.  This fixes parsing of HildonTelephoneEditorFormat in
-	hildon-libs.
-	* tools/pm/Enum.pm (parse_values): Check whether the enumeration
-	constants actually have a common module prefix before attempting
-	to remove it.  This fixes the incorrect parsing of inconsistently
-	named enums in hildon-libs.
-
-2006-11-27  Daniel Elstner  <danielk@openismus.com>
-
-	* tools/enum.pl (form_names): Break the loop if the length of the
-	common prefix reaches zero.  This fixes the infinite loop when
-	processing the inconsistently named enumeration constants of the
-	Hildon libraries.
-
-2006-11-22  Oliver Nittka  <oly@nittka.com>
-
-        * glib/src/value_basictypes.cc.m4: When registering float parameters,
-        use -G_MAXFLOAT instead of G_MINFLOAT. Since we first implemented this,
-        the glib documentation has been updated to make it clearer that this is
-        the real minimum and G_MINFLOAT is the minimum positive value.
-        Do the same for doubles too.
-
-2.12.3:
-
-2006-11-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/Makefile.am: Add enum.pl to the dist, so that it is in 
-	tarballs. Someone saw it mentioned in the appendix, but could not 
-	find it in the tarball.
-
-2006-11-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/reference/Doxyfile.in: Add PREDEFINES for the optional API, 
-	so that the documentation shows the regular API.
-
-2006-11-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/glibmm/objectbase.cc:
-	* glib/glibmm/objectbase.h: Added connect_property_changed(), 
-	as an alternative to use when the property proxies are not 
-	available because GLIBMM_PROPERTIES_ENABLED is not defined.
-	SignalProxyProperty::connect(): Use notify::propertyname instead of 
-	just notify, so do not have to check the property name later. This 
-	should be more efficient (when this is used, rarely).
-	* glib/glibmm/propertyproxy_base.cc:
-	* glib/glibmm/propertyproxy_base.h: Move PropertyProxyConnectionNode
-	into the header, so we can reuse it for connect_property_changed(). 
-
-2006-10-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* Makefile.am:
-	* docs/Makefile.am:
-	* docs/Makefile_web.am_fragment:
-	* docs/images/Makefile.am:
-	* docs/reference/Makefile.am:
-	* docs/reference/README:
-	* examples/Makefile.am: Upload to the new hoster instead of to sourceforge.
-	Abstracted the host and path names into docs/Makefile_web.am_fragment to 
-	avoid duplication.
-
-2006-10-04  Murray Cumming  <murrayc@murrayc.com>
-
-        * glib/glibmm/class.cc:
-        * glib/src/iochannel.ccg:
-        * glib/src/markup.ccg: Add a silly line to avoid unused parameters
-        when GLIBMM_EXCEPTION_ENABLED is not set.
-        * glib/glibmm/error.h: Do not use G_GNU_NO_RETURN on the version
-        of throw_exception() that returns, to avoid a warning.
-
-2006-09-19  Ralf Stephan  <ralf@ark.in-berlin.de>
-
-	* glib/glibmm/ustring.h: 
-	ustring(const ustring& src, size_type i, size_type n=npos)
-	and 
-	ustring(const char* src, size_type n) constructors:
-	In the reference documentation, mention explicitly that 
-	n is the number of _UTF-8_ characters, rather than 
-	ASCII characters (bytes).
-
-2.12.2:
-
-2006-09-28  Cedric Gustin  <cedric.gustin@gmail.com>
-	
-	* MSVC_Net2003/glibmm/glibmm.vcproj: Remove sarray from list of
-	source and header files.
-
-2006-09-26  Murray Cumming  <murrayc@murrayc.com>
-
-        * glib/glibmmconfig.h.in: For win32, define
-        GLIBMM_ARG_ENABLE_API_DEFAULT_SIGNAL_HANDLERS to 1,
-        instead of just defining it to nothing.
-        * scripts/reduced.m4: In the AC_ARG_ENABLE() to
-        define (or not) GLIBMM_ARG_ENABLE_API_DEFAULT_SIGNAL_HANDLERS,
-        use api-default-signal-handlers as the first parameter
-        instead of api-exceptions (a copy/paste error), though it does
-        not seem to make any difference.
-        Bug #357830.
-
-2.12.1:
-
-2006-09-14  Johannes Schmid <jhs@gnome.org>
-
-	* tools/m4/class_shared.m4: Change _IMPLEMENTS_INTERFACE to 
-	_IMPLEMENTS_INTERFACE_CC so we can have more control over it, 
-	by generating the _IMPLEMENTS_INTERFACE_CC from the WrapParser.pm.
-	* tools/m4/method.m4:
-	* tools/m4/signal.m4:
-	* tools/m4/vfunc.m4: Added optional parameters that result in 
-	#ifdefs around methods, signals, vfuncs, etc.
-	* tools/pm/Output.pm: Addef ifdef() and endif().
-	output_wrap_vfunc_h(), output_wrap_vfunc_cc(),
-	output_wrap_default_signal_handler_h(), 
-	output_wrap_default_signal_handler_cc(),
-	output_wrap_meth(),
-	output_wrap_create(),
-	output_wrap_sig_decl(): Support optional ifdefs around  
-	declarations and implementations, by calling ifdef() and endif(), 
-	or by passing the extra argument to the m4 macros.
-	* tools/pm/WrapParser.pm: parse_and_build_output(): 
-	Parse _IMPLEMENTS_INTERFACE, and call the new on_implements_interface() 
-	method, which uses the new output_implements_interface() method, 
-	so it can have an optional ifdef parameter.
-	on_wrap_method(), on_wrap_create(), on_wrap_vfunc(), output_wrap_signal(),
-	output_wrap_vfunc(): Handle the optional ifdef (with a parameter) option 
-	for the _WRAP*() macros.
-
-	This adds support for disabling certain features by using the new
-	"ifdef" argument for methods, vfuncs, signals and interfaces.
-
-2006-08-18  Cedric Gustin  <cedric.gustin@gmail.com>
-	
-	* MSVC_Net2003/*.vcproj: Updated for glibmm-2.12.
-
-2.12.0:
-
-2.11.3:
-
-2006-04-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in:
-	* glib/glibmmconfig.h.in:
-	* scripts/reduced.m4: Added a --enable-api-default-signal-handlers option. This defines 
-	GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED, which is used to #ifdef default signal handlers.
-	This saves on library code size (less code and API symbols) and application code size and 
-	loading time (less virtual methods, which must be imported and resolved at load time) and 
-	per-object memory size (smaller object sizes because of less virtual methods.) 
-	* tools/m4/class_interface.m4:
-	* tools/m4/class_shared.m4: Put default signal handler code in #ifdefs.
-
-2.11.2:
-
-2006-07-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Reverted the previous patch slightly to unbreak glibmmconfig.h.
-
-2.11.1:
-
-2006-07-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Quote GLIBMM_*_VERSION to avoid m4 warnings. Patch from 
-	Bug #347076 from Kevin McBride.
-	* scripts/sun.m4: Quote GLIBMM_PROG_CXX_SUN to avoid an m4 warning. 
-	Patch from Bug #347077 from Kevin McBride.  
-
-2006-07-16  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* glib/src/date.ccg: fix implementation of Glib::Date::set_time_current() so
-	that it doesn't set the date to Dec 31, 1969.
-
-2006-06-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/glibmm/object.h: Check whether DestroyNotify is defined, so we can warn about 
-	including X11/Xlib.h before this header, which will break things. 
-	Bug #316726 from Mert Tugcu and Javeed Shaikh.
-
-2006-06-09  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* glib/glibmm/objectbase.h : Inline the set_property and
-	get_property methods. This is required by mingw32-gcc as
-	ObjectBase is explicitly dllexported.
-
-2006-06-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/src/convert.ccg: When using --enable-api-exception=no, only try to get the Glib::Error 
-	when the GError is not null.
-
-2006-05-18  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/m4/method.m4: _METHOD(): When using errthrow, actually print the function call even if 
-	the return type is 0.
-
-2006-05-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/m4/method.m4:  _METHOD(), _STATIC_METHOD(): Remove spaces before dnl statements, 
-	to avoid unwanted indentation in .cc files.
-
-2006-05-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/m4/convert_base.m4: _CONVERT(): If the return type is void, use the unconverted 
-	statement, not no statement. This prevents some void methods from being totally empty. 
-	This was a (very bad) regression introduced by the optional API changed. 
-	Bug #341895 from Philip Langdale.
-	* tools/m4/method.m4: _METHOD(), _STATIC_METHOD(): Attempt to remove unnecessary newlines, 
-	though some indenting spaces slipped in instead. Must fix that. 
-
-2006-05-14  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/glibmm/value.cc:
-	* glib/glibmm/value.h: Restored the init(GValue*) method that was lost when 
-	merging changes from the glibmm-2-10 branch.
-
-2006-05-09  Murray Cumming  <murrayc@murrayc.com>
- 
-	* glib/glibmm/ustring.cc:
-	* glib/src/date.ccg:
-	* glib/src/convert.ccg:
-	* glib/src/convert.hg: Added #ifdefed versions for the case that 
-	exceptions are disabled.
-
-2006-05-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in:
-	* scripts/reduced.m4: Moved --enable-deprecated-api macro into scripts/reduced.m4.
-	Added the --enable-api-exceptions macro that was missing from my last commit.
-
-2006-04-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in:
-	* scripts/reduced.m4: Added --enable-api-exceptions option. When this 
-	is used, methods that would normally throw an exception will now take 
-	an extra std::auto_ptr<Glib::Error> argument that should be checked with 
-	auto_ptr::get().
-	* glib/glibmmconfig.h.in: Undef the GLIBMM_EXCEPTIONS_ENABLED, 
-	so it will be defined.
-	* tools/m4/gerror.m4: throw_func() returns an auto_ptr of a 
-	Glib::Error when exceptions are disabled.
-	* tools/m4/method.m4:
-	* tools/pm/Output.pm: on_wrap_method(): Added alternative API with 
-	#ifdefs
-	* tools/m4/signal.m4:
-	* tools/m4/signalproxy_custom.m4:
-	* tools/m4/vfunc.m4: Put #ifdefs around the exception re-throwing 
-	try/catch blocks.
-	* glib/glibmm/dispatcher.cc:
-	* glib/glibmm/dispatcher.h:
-	* glib/glibmm/error.cc:
-	* glib/glibmm/error.h:
-	* glib/glibmm/exceptionhandler.cc:
-	* glib/glibmm/exceptionhandler.h:
-	* glib/glibmm/main.cc:
-	* glib/glibmm/signalproxy.cc:
-	* glib/glibmm/streamiochannel.cc:
-	* glib/glibmm/stringutils.cc:
-	* glib/glibmm/threadpool.cc:
-	* glib/src/iochannel.ccg:
-	* glib/src/iochannel.hg:
-	* glib/src/markup.ccg:
-	* glib/src/spawn.ccg:
-	* glib/src/thread.ccg: Put #ifdefs around try/catch blocks, and 
-	use alternative API when appropriate.
-	* examples/iochannel_stream/fdstream.cc:
-	* examples/markup/parser.cc:
-	* examples/options/main.cc: Adapted examples to 
-	the alternative API, with #ifdefs
-	* tools/m4/convert_base.m4: Avoid any conversion if the result is 
-	void, to allow _WRAP_METHOD() to ignore bool results, so we can 
-	generate some methods that are currently hand-coded.
-
-2006-05-09  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/glibmm/value.cc:
-	* glib/glibmm/value.h: Added init(const GValue*), so that we can copy GValue instances 
-	of any type at runtime. Needed by libgdamm, which returns const GValue* instances.
-
-This is the HEAD branch, for API additions. See also the glibmm-2-10 branch.
-
-2.10.1:
-
-2006-04-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/m4/signalproxy_custom.m4: Remove this file because it is not installed and 
-	does not seem to be used.
-
-2006-04-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/m4/signal.m4: Mark the (private) signal info callback functions as 
-	static, to save on code size. 
-
-2006-04-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/pm/WrapParser.pm: Parse a new optional constversion parameter for 
-	_WRAP_METHOD(), to save on code size by just calling the non-const overload 
-	instead of generating almost identical code.
- 	* tools/m4/method.m4: _METHOD(): Take extra parameters for use when constversion is used.
-	* tools/pm/Output.pm: Send the extra parameters to _METHOD().
-	* docs/internal/using_gmmproc.txt: Documented the new constversion option.
-
-2006-04-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/glibmm/main.cc:
-	* glib/glibmm/objectbase.cc:
-	* glib/glibmm/property.cc:
-	* glib/glibmm/ustring.cc:
-	* glib/glibmm/value_custom.cc: 
-	* glib/src/spawn.ccg: Mark private functions as 
-	static, to stop them being exported in the API, to reduce the 
-	library code size slightly.
-	* tools/m4/signal.m4: Make generated callback functions static, for 
-	the same reasons.
-
-2006-04-07  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* README.win32: Updated for Mingw-4.1.
-
-2006-04-06  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* MSVC_Net2003/*.vcproj: Embed the manifest file into executables
-	in the case of the Debug target.
-	* README.win32: Fixed a few typos.
-	* build_shared/Makefile_build.am_fragment: Add -DGLIBMM_BUILD to
-	the extra_defines compiler flags (switch between
-	dllexport/dllimport on win32).
-	* glib/glibmmconfig.h.in: Define GLIBMM_DLL when building with
-	mingw32/cygwin. This makes the GLIBMM_API tag (and GTKMM_API for
-	gtkmm) active with these two platforms, as required by bug
-	#309030.  
-	* glib/glibmm/object.h, glib/glibmm/objectbase.h : Tag the Object
-	and ObjectBase classes with GLIBMM_API to make Visual Studio happy.
-
-2.10.0:
-
-2006-02-25  Murray Cumming  <murrayc@murrayc.com>
- 
-	* tools/pm/DocsParser.pm: looklookup_documentation(): Put the 
-	@deprecated text immediately after the main description, before 
-	the parameters, so that Doxygen actually uses it.
- 
-2006-02-25  Murray Cumming  <murrayc@murrayc.com>
- 
-	* tools/pm/DocsParser.pm: looklookup_documentation(): Accept an 
-	extra deprecated_documentation parameter, to be appended to the 
-	Doxygen documentation.
-	* tools/pm/Output.pm: output_wrap_meth(): Put the documentation 
-	inside the deprecation #ifdef, for neatness.
-	* tools/pm/WrapParser.pm: on_wrap_method(): Read an optional string 
-	after the optional deprecated parameter, used to say why the 
-	method is deprecated, in case it was not deprecated by the C API, 
-	in which case it would already have documentation for this.
-
-2006-02-27  Cedric Gustin <cedric.gustin@gmail.com>
-
-	* README.win32: Updated for glibmm-2.8 (MS Visual Studio 2005).
-	* glib/glibmm/ustring.h: Tag npos with GLIBMM_API, in order to
-	dllexport it on win32. Bug #332438.
-	* MSVC_Net2003/*.vcproj: Updated for Visual Studio 2005. Added the
-	/vd2 compiler flag (Bug #158040).
-	* MSVC_Net2003/glibmm.sln: Updated for Visual Studio 2005.
-	* MSVC_Net2003/gendef/gendef.cc: Redirect output of dumpbin to a
-	file.
-	* glib/glibmmconfig.h.in: Undefined
-	GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS for MSVC.
-
-2006-02-03  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/internal/using_gmmproc.txt: Section about regenerating .defs:
-	Repeat the hint about extra_defs_gen here.
-
-2006-02-27  Cedric Gustin <cedric.gustin@gmail.com>
-
-	* glib/glibmm/ustring.h: Tag npos with GLIBMM_API, in order to
-	dllexport it on win32. Bug #332438.
-
-2006-02-07  Rob Page  <page.rob@gmail.com>
-
-	* glib/glibmm/ustring.h: fix a typo in the documentation for uppercase()
-
-2.9.1:
-
-2006-01-28  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/src/optiongroup.ccg: add_entry_with_wrapper(): Copy the 
-	CppOptionEntry into the map _after_ setting entry_ so that we 
-	really delete it in release_c_arg(), to avoid a memory leak.
-
-2006-01-28  Rob Page <rob@gmail.com>
-
-	* docs/reference/glibmm_header.html_fragment: Fix the link 
-	to the Main page. Bug #328299.
-
-2006-01-27  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/src/optionentry.ccg: Constructor: Avoid memory 
-	leak caused by double instantiation of gobject_.
-
-2005-12-16  Murray Cumming <murrayc@murrayc.com>
-
-	* glib/glibmm/object.h:
-	* glib/glibmm/objectbase.h: Hide some internal stuff 
-	from Doxygen. Add/Improve the Doxygen documentation.
-	* glib/src/convert.hg: Correct the declaration of 
-	filename_display_name() to match the implementation. 
-	Previously this would have been unusable due to a linker 
-	error.
-
-2005-11-30  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/reference/Doxyfile.in: Define the @newin aliases, 
-	as in gtkmm.
-	* tools/pm/DocsParser.pm: Convert Since: in gtk-doc 
-	text to @newin for our doxygen docs.
-
-2005-11-29  Murray Cumming <murrayc.com>
-
-	* build_shared/Makefile_build.am_fragment:
-	* configure.in: Added --enable-use-deprecations, 
-	defaulting to no (do not check for them), so that 
-	the tarball will still build when newer versions 
-	of glib deprecate some API. 
-	* examples/Makefile.am_fragment: Use the 
-	deprecation, if wanted.
-
-2005-11-29  Murray Cumming <murrayc@murrayc.com>
-
-	* build_shared/Makefile_build.am_fragment:
-	* configure.in: Added --enable-deprecated-api 
-	option. When set to disabled, it does not build 
-	deprecated API. This reduces the size of the library, 
-	and might be useful for embedded devices.
-	* glib/src/date.ccg:
-	* glib/src/date.hg: Use _DEPRECATE_IFDEF_START/END 
-	around the deprecated set_time() method.
-
-2005-11-29  Murray Cumming <murrayc@murrayc.com>
-
-	* tools/m4/base.m4: Add 
-        _DEPRECATE_IFDEF_START and _DEPRECATE_IFDEF_END 
-	macros, to #ifdef-out generated methods. 
-	Added _DEPRECATE_IFDEF_CLASS_START and 
-	_DEPRECATE_IFDEF_CLASS_END for whole classes. 
-	Put _DEPRECATE_IFDEF_CLASS* around all generated 
-	code. It does nothing if the class is not deprecated.
-	* tools/m4/class_gtkobject.m4: Add _DEPRECATED macro, 
-	used to mark a class as deprecated.
-	* tools/m4/method.m4: Take an extra parameter, to 
-	optionally mark the method as deprecated, to add 
-	#ifdefs around the code, with 
-	_DEPRECATE_IFDEF_START/END
-	* tools/pm/Output.pm: _DEPRECATE_IFDEF_START/END 
-	around the declarations of deprecated methods.
-	* tools/pm/WrapParser.pm: Check for an optional 
-	deprecated parameter to _WRAP_METHOD(). 
-	* tools/m4/member.m4: Allow optional deprecated 
-	method for _MEMBER_GET/SET*() to ifdef the code 
-	out.
-	* tools/generate_wrap_init.pl.in: Put an #ifdef 
-	around use of deprecated classes.
-
-2005-11-23  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.in: Depend on glib 2.9, which 
-	has new API.
-	* glib/src/date.ccg:
-	* glib/src/date.hg: Wrap glib_date_set_time_t() 
- 	and glib_date_set_time_val(). Deprecate  
-	set_time(GTime) in favour of the new method 
-	overloads. Added set_time_current(), wrapping the 
-	case that the time_t is 0.
-
-This is the HEAD branch, for new API, targetting glib 2.9. See also the 
-glibmm-2-8 branch.
-
-2.8.2:
-
-2005-11-23  Murray Cumming <murrayc@murrayc.com>
-
-	* glib/glibmm/containers.h: Do not use g_assert() in 
-	a header, because g++ sometimes warns that it has 
-	no effect.
-
-2005-10-29  Murray Cumming <murrayc@murrayc.com>
-
-	* scripts/macros.m4: AL_PROG_GNU_MAKE(): 
-	Use $MAKE-make instead of $ac_make, which 
-	apparently fixes a build problem on some 
-	Solaris systems. Thanks to Mark Rouchal in 
-	bug #307480.
-
-2.8.1:
-
-2005-10-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Check for glib 2.8. Bug #317913.
-
-2.8.0:
-
-Updated NEWS and increased version to 2.8.0.
-
-2.7.3:
-
-2005-08-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/src/glib_docs.xml: Regenerated with docextract_to_xml.py
-	* glib/src/glib_enums.defs: Regenerated with enums.pl
-	* glib/src/glib_functions.defs: Regenerated with h2defs.py
-
-2.7.2:
-
-2005-07-16  Murray Cumming <murrayc@murrayc.com
-
-	* glib/glibmm/miscutils.cc: Reimplemented build_filename() and 
-	build_path() with the new non-vararg functions in glib 2.7, 
-	instead of implementing them in gtkmm.
-	* glib/src/glib_enums.defs: Regenerated with enums.pl
-	* glib/src/optionentry.hg: Added FLAG_NO_ARG, FLAG_FILENAME, 
-	FLAG_OPTIONAL_ARG, and FLAG_NOALIAS enum values.
-
-
-2.7.1:
-
-2005-06-08  Murray Cumming <murrayc@murrayc.com
-
-	* glib/glibmm/propertyproxy.h: 
-	PropertyProxy_ReadOnly<>::get_value(),
-  	PropertyProxy_WriteOnly<>::set_value(): Add implementations 
-	instead of casting to unrelated PropertyProxy() and calling it 
-	there. The AIX compiler did not like this hack. Bug #301610
-
-2005-06-07  Cedric Gustin <cedric.gustin@swing.be>
-
-	* glib/glibmm/miscutils.cc: In get_home_dir, return an empty
-	string when HOME is not defined (Win9x). Bug #306310 from Michael
-	Hofmann.
-	* glib/glibmm/miscutils.h: Updated docstring for the get_home_dir
-	method.
-
-2005-04-27  Murray Cumming <murrayc@murrayc.com>
-
-	* examples/child_watch/main.cc:
-	* examples/thread/dispatcher.cc:
-	* examples/thread/thread.cc:
-	* glib/glibmm/dispatcher.cc: Inherit signal handler objects from 
-	sigc::trackable. This is necessary with some libsigc++ patches, 
-	though not currently necessary with regular libsigc++.
-
-2005-04-22  Murray Cumming  <murrayc@murrayc.com>
-
-	* glib/src/gmodule_enums.defs: Regenerate with enums.pl
-	* glib/src/gmodule_functions.defs: Regenerate with h2defs.py
-	This adds the BIND_LOCAL enum value. Bug #172748 from 
-        Phillip Neiswanger.
-
-2005-04-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* tool/pm/Output.pm: output_wrap_property(): Do not add the 
-	const read-only method override if the property can not be read. Be 
-	careful because this removes a little API from generated code. You 
-	should hand-code the wrongly-generated methods and mark them as 
-	deprecated.
-	* glib/glibmm/refptr.h: Added cast_const<>, like the existing 
-	cast_dynamic<> and cast_static.
-
-2005-03-31  Murray Cumming <murrayc@murrayc.com>
-
-	* glib/src/glib_functions.defs: Updated with 
-	h2defs.py.
-
-2005-03-13  Yair Hershkovitz <yairhr@gmail.com>
-
-	* glib/glibmm/main.h,
-	glib/glibmm/main.cc: Added MainContext::signal_child_watch()
-	* examples/: Added child_watch/ example   
-  
-2005-03-11  Yair Hershkovitz <yairhr@gmail.com>
-
-	* glib/glibmm/main.h, glib/glibmm/main.cc: 
-	Add Glib::SignalChildWatch class, Glib::signal_child_watch()
-
-This is the HEAD branch, for new API. Bug fixes that do not change or add 
-API should also be applied to the glibmm-2-6 branch.
-
-2005-03-09  Cedric Gustin <cedric.gustin@swing.be>
-
-	* MSVC_Net2003/Makefile.am: Add blank.cpp to EXTRA_DIST.
-	* MSVC_Net2003/glibmm/glibmm.vcproj: Remove sarray.cc from the
-	list of source files.
-	* MSVC_Net2003/examples/*/*.vcproj,
-	MSVC_Net2003/tests/glibmm_value/glibmmvalue.vcproj: Change name of
-	PDB file to $(OutDir)/$(TargetName).pdb. 
-	
 2.6.1:
 
 2005-03-07  Murray Cumming  <murrayc@murrayc.com>
diff --git a/libs/glibmm2/INSTALL b/libs/glibmm2/INSTALL
index 23e5f25d0e..095b1eb406 100644
--- a/libs/glibmm2/INSTALL
+++ b/libs/glibmm2/INSTALL
@@ -1,7 +1,7 @@
 Installation Instructions
 *************************
 
-Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free
+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004 Free
 Software Foundation, Inc.
 
 This file is free documentation; the Free Software Foundation gives
@@ -102,16 +102,16 @@ for another architecture.
 Installation Names
 ==================
 
-By default, `make install' installs the package's commands under
-`/usr/local/bin', include files under `/usr/local/include', etc.  You
-can specify an installation prefix other than `/usr/local' by giving
-`configure' the option `--prefix=PREFIX'.
+By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc.  You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PREFIX'.
 
    You can specify separate installation prefixes for
 architecture-specific files and architecture-independent files.  If you
-pass the option `--exec-prefix=PREFIX' to `configure', the package uses
-PREFIX as the prefix for installing programs and libraries.
-Documentation and other data files still use the regular prefix.
+give `configure' the option `--exec-prefix=PREFIX', the package will
+use PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
 
    In addition, if you use an unusual directory layout you can give
 options like `--bindir=DIR' to specify different values for particular
@@ -159,7 +159,7 @@ where SYSTEM can have one of these forms:
 need to know the machine type.
 
    If you are _building_ compiler tools for cross-compiling, you should
-use the option `--target=TYPE' to select the type of system they will
+use the `--target=TYPE' option to select the type of system they will
 produce code for.
 
    If you want to _use_ a cross compiler, that generates code for a
@@ -189,13 +189,8 @@ them in the `configure' command line, using `VAR=value'.  For example:
 
      ./configure CC=/usr/local2/bin/gcc
 
-causes the specified `gcc' to be used as the C compiler (unless it is
-overridden in the site shell script).  Here is a another example:
-
-     /bin/bash ./configure CONFIG_SHELL=/bin/bash
-
-Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent
-configuration-related scripts to be executed by `/bin/bash'.
+will cause the specified gcc to be used as the C compiler (unless it is
+overridden in the site shell script).
 
 `configure' Invocation
 ======================
diff --git a/libs/glibmm2/Makefile.am b/libs/glibmm2/Makefile.am
index c19f750982..8e49568562 100644
--- a/libs/glibmm2/Makefile.am
+++ b/libs/glibmm2/Makefile.am
@@ -1,8 +1,15 @@
 ACLOCAL_AMFLAGS	= -I scripts
 
-SUBDIRS		= glibmm 
+SUBDIRS = glibmm
 DIST_SUBDIRS	= $(SUBDIRS)
 
+EXTRA_DIST	= build_shared/Makefile_build.am_fragment \
+		  build_shared/Makefile_build_gensrc.am_fragment \
+		  build_shared/Makefile_gensrc.am_fragment \
+		  build_shared/Makefile_gensrc_platform.am_fragment \
+		  build_shared/Makefile_build_extra.am_fragment \
+		  CHANGES glibmmconfig.h.in glibmm-2.4.pc.in
+
 glibmm_includedir       = $(includedir)/glibmm-2.4
 glibmm_include_HEADERS  = glibmm.h
 
@@ -14,16 +21,3 @@ pkgconfig_DATA          = glibmm-2.4.pc
 
 all-local:
 	@echo "*** Everything completed ***"
-
-dist-hook:
-	@echo; echo; \
-	echo "**********************************************************"; \
-	echo "* IMPORTANT NOTICE:                                      *"; \
-	echo "*                                                        *"; \
-	echo "* Be sure you have done a complete build before running  *"; \
-	echo "* 'make dist' or 'make distcheck', because otherwise     *"; \
-	echo "* the tarball will _not_ contain the dependency rules    *"; \
-	echo "* generated by the compiler.                             *"; \
-	echo "**********************************************************"; \
-	echo; echo
-
diff --git a/libs/glibmm2/NEWS b/libs/glibmm2/NEWS
index e3811547e8..9edbf66137 100644
--- a/libs/glibmm2/NEWS
+++ b/libs/glibmm2/NEWS
@@ -1,163 +1,3 @@
-2.12.5:
-
-* Fix code generation when using the latest m4, and functions named 
-  mkstemp, as experienced on Ubuntu Feisty.
-  Bug #397167 (Dodji Seketeli, Daniel Elstner)
-
-2.12.4:
-
-* gmmproc improvements:
-  - gmmproc: Allow () in property and signal documentation.
-  - gmmproc: Do not try to remove a common prefix from the 
-  C enam values, if there is no common prefix.
-  - enum.pl: Allow whitespace in front of an enum typedef. 
-  (Daniel Elstner)
-  - enum.pl: Fix an infinite loop.
-
-* Glib::Value: When registering float parameters, use 
-  G_MAXFLOAT as the minimum, instead of G_MINFLOAT.
-  Likewise for doubles.
-  (Oliver Nittka)
-
-2.12.3:
-
-* ObjectBase: Added connect_property_changed(), 
-  as an alternative to use when the property proxies are not 
-  available because GLIBMM_PROPERTIES_ENABLED is not defined.
-  (Murray Cumming)
-* Documentation: 
-  - Small ustring reference documentation improvement.
-  (Ralf Stephan)
-
-2.12.2
-
-*Build:
- - Fix for api-default-signal-handlers option.
-   Bug #357830 (Matt Hoosier)
- - win32: Remove unused source file from Visual Studio project.
-   (Cedric Gustin)
-
-2.12.1:
-
-* Support optional ifdef parameters in the .hg macros, 
-  to allow, for instance the --enable-atk=no option, 
-  to disable the build and use of the atkmm API, 
-  for use in embedded environments.
-  (Johannes Schimd, Murray Cuming, Openismus)
-
-2.12.0:
-
-Changes sinze 2.10:
-* Added the --enable-api-default-signal-handlers option, for use in 
-  embedded environments that have reduced resources. See configure --help 
-  for the other subsets.
-* Value: Added init(const GValue*), so we can copy GValue instances 
-  of any type at runtime. Needed by the new branch of libgdamm.
-
-2.11.3:
-
-* Build: Added the --enable-api-default-signal-handlers option, for use in 
-  embedded environments that have reduced resources. See configure --help 
-  for the other subsets.
-
-2.11.2:
-
-* Date: Fix implementation of Glib::Date::set_time_current() so
-  that it doesn't set the date to Dec 31, 1969.
-  (Jonathon Jongsma)
-* Value: Added init(const GValue*), so we can copy GValue instances 
-  of any type at runtime. Needed by the new branch of libgdamm.
-  (Murray Cumming)
-* Added a #warning to warn about including X11/Xlib.h before a glibmm header, 
-  which would break things. Bug #316726 from Mert Tugcu and Javeed Shaikh.
-  (Murray Cumming)
-* Build: 
-  - Quote some m4 macros to avoid warnings. Bugs (with patches) #347076 
-  and #347077
-  (Kevin McBride).
-  - Fix exporting of get/set_property() on mingw32-gcc.
-  (Cedric Gustin)
-
-
-
-
-2.10.1
-
-* Windows Build:
- - Define GLIBMM_DLL when building with mingw32 or cygwin, 
-   because it is needed by gtkmm. Bug #309030
- (Cedric Gustin)
-* OptionGroup: Allow default values, by not initializing them all.
-  (Armin Burgmeier)
-* Slight code size reduction by marking private functions as static.
-  (Murray Cumming)
-
-2.10.0:
-
-* Windows Build:
- - ustring.h: Tag npos with GLIBMM_API, in order to
-   dllexport it on win32. Bug #332438.
- - Updated MSVC++ build files and README, for MS Visual Studio 2005.
- (Cedric Gustin)
-* gmmproc code generator: 
- - WRAP_METHOD() Take an extra optional argument: deprecated deprecationtext - 
-  so that we can insert the appropriate doxygen tag in the documentation, where 
-  the C documentation does not do it for us.
-
-2.9.1:
-
-* Date:
-  - Added set_time(time_t), set_time(GTimeVal), and deprecated  
-    set_time(GTime)
-  - Added set_time_current().
-  (Murray Cumming)
-* Build: Added --enable-deprecated-api  option. When set to disabled, 
-  it does not build deprecated API. This reduces the size of the 
-  library, and might be useful for embedded devices.
-  (Murray Cumming)
-
-2.8.2:
-
-* Solaris build fix: Correct the detection 
-  of make. (Mark Rouchal)
-
-2.8.1:
-
-* Build: Check for glib 2.8.
-
-2.8.0:
-
-API additions since glibmm 2.6:
-
-* GModule: Add BIND_LOCAL enum value.
-  (Bug #172748 from Phillip Neiswanger).
-* MainContext Added signal_child_watch()
-  and examples/child_watch.
-  (Yair Hershkovitz)
-* OptionEntry: Added FLAG_NO_ARG, FLAG_FILENAME, 
-  FLAG_OPTIONAL_ARG, and FLAG_NOALIAS enum values.
-  (Murray Cumming)
-
-2.7.3:
-
-* Updated reference documentation from glib documentation.
-
-2.7.2:
-
-* OptionEntry: Added FLAG_NO_ARG, FLAG_FILENAME, 
-  FLAG_OPTIONAL_ARG, and FLAG_NOALIAS enum values.
-* build_filename() and build_path(): Now use the implementation 
-  from glib.
-
-2.7.1:
-
-* GModule: Add BIND_LOCAL enum value.
-  (Bug #172748 from Phillip Neiswanger).
-* MainContext Added signal_child_watch()
-  and examples/child_watch.
-  (Yair Hershkovitz)
-* Fixes from 2.6.2.
-
 2.6.1:
 
 * Interface::add_interface(): Disabled the check for a second call, 
diff --git a/libs/glibmm2/README b/libs/glibmm2/README
index 341c67e439..eef49fd1a7 100644
--- a/libs/glibmm2/README
+++ b/libs/glibmm2/README
@@ -1,4 +1,31 @@
-This is glibmm, a C++ API for parts of glib that are useful for C++.
-See http://www.gtkmm.org
+This is the unstable version of gtkmm, aimed at Gtk+ 2.0.x.
+See CHANGES for a comparison with gtkmm 1.2.
 
+Contents:
+* Your unstable development environment
+* Required libraries:
 
+Your unstable development environment
+-------------------------------------
+
+Until the GTK+ 2.0 / GNOME 2.0 platform is stable, you should try to separate these unstable libraries from your stable GTK+ 1.2 / GNOME 1.2/1.4 libraries. You can do this by installing the unstable libraries into a different prefix.
+e.g. ./configure --prefix=/usr/devgnome2
+
+When using the development libraries, you will need to modify some environment variables. This will be easier if you create a file (e.g. devgnome2) in your home directory that contains these commands:
+
+export PATH="/usr/devgnome2/bin:$PATH"; export LD_LIBRARY_PATH="/usr/devgnome2/lib" ; export PKG_CONFIG_PATH="/usr/devgnome2/lib/pkgconfig:$PKG_CONFIG_PATH" ;
+
+You can then type
+# source devgnome2
+to prepare your environment before building or working with the development libraries.
+
+You may also need to edit /etc/ld.so.conf to add /usr/devgnome2/lib, and then type /sbin/ldconfig to re-process the ld.so.conf.
+
+
+The vicious-build-scripts module in cvs.gnome.org might help you with this, if you can get it to work.
+
+Required Libraries
+------------------
+
+* Of course, you will need gtk+ 2 and its dependencies.
+* libsigc++ 1.2 (A release, or libsigc++-1.2 from cvs)
diff --git a/libs/glibmm2/SConscript b/libs/glibmm2/SConscript
index 8fc3e7003d..267f846203 100644
--- a/libs/glibmm2/SConscript
+++ b/libs/glibmm2/SConscript
@@ -10,11 +10,10 @@ glibmm2_files = glob.glob('glibmm/*.cc')
 Import('env libraries install_prefix')
 
 glibmm2 = env.Copy()
-glibmm2.Merge([ libraries['sigc2'], 
-                libraries['glib2'] ])
+glibmm2.Merge([libraries['sigc2'], libraries['glib2']])
 
 glibmm2.Append(CXXFLAGS='-DHAVE_CONFIG_H')
-glibmm2.Append(CXXFLAGS='-DGLIBMM_DISABLE_DEPRECATED')
+#glibmm2.Append(CXXFLAGS='-DG_DISABLE_DEPRECATED')
 glibmm2.Append(CXXFLAGS='-DG_LOG_DOMAIN=\\\"glibmm\\\"')
 
 libglibmm2 = glibmm2.SharedLibrary('glibmm2', glibmm2_files)
diff --git a/libs/glibmm2/configure.ac b/libs/glibmm2/configure.ac
index 9c6f263911..b34fbdbe00 100644
--- a/libs/glibmm2/configure.ac
+++ b/libs/glibmm2/configure.ac
@@ -18,13 +18,13 @@ AC_PREREQ(2.50)
 #  Version and initialization
 #########################################################################
 GLIBMM_MAJOR_VERSION=2
-GLIBMM_MINOR_VERSION=12
-GLIBMM_MICRO_VERSION=5
+GLIBMM_MINOR_VERSION=6
+GLIBMM_MICRO_VERSION=1
 GLIBMM_VERSION=$GLIBMM_MAJOR_VERSION.$GLIBMM_MINOR_VERSION.$GLIBMM_MICRO_VERSION
 GLIBMM_RELEASE=$GLIBMM_MAJOR_VERSION.$GLIBMM_MINOR_VERSION
-AC_DEFINE_UNQUOTED([GLIBMM_MAJOR_VERSION], $GLIBMM_MAJOR_VERSION, [Major Version])
-AC_DEFINE_UNQUOTED([GLIBMM_MINOR_VERSION], $GLIBMM_MINOR_VERSION, [Minor Version])
-AC_DEFINE_UNQUOTED([GLIBMM_MICRO_VERSION], $GLIBMM_MICRO_VERSION, [Micro Version])
+AC_DEFINE_UNQUOTED(GLIBMM_MAJOR_VERSION, $GLIBMM_MAJOR_VERSION)
+AC_DEFINE_UNQUOTED(GLIBMM_MINOR_VERSION, $GLIBMM_MINOR_VERSION)
+AC_DEFINE_UNQUOTED(GLIBMM_MICRO_VERSION, $GLIBMM_MICRO_VERSION)
 AC_SUBST(GLIBMM_MAJOR_VERSION)
 AC_SUBST(GLIBMM_MINOR_VERSION)
 AC_SUBST(GLIBMM_MICRO_VERSION)
@@ -38,7 +38,7 @@ AC_SUBST(GLIBMM_RELEASE)
 #  ? :+1 : ?   == just some internal changes, nothing breaks but might work 
 #                 better
 # CURRENT : REVISION : AGE
-LIBGLIBMM_SO_VERSION=1:24:0
+LIBGLIBMM_SO_VERSION=1:13:0
 AC_SUBST(LIBGLIBMM_SO_VERSION)
 
 AC_CONFIG_AUX_DIR(scripts)
@@ -69,34 +69,7 @@ AC_PROG_MAKE_SET
 AC_CANONICAL_BUILD
 AC_CANONICAL_HOST
 
-dnl Used for enabling the "-no-undefined" flag while generating DLLs
-dnl Copied from the official gtk+-2 configure.in
-AC_MSG_CHECKING([for some Win32 platform])
-case "$host" in
-  *-*-mingw*|*-*-cygwin*)
-    platform_win32=yes
-    ;;
-  *)
-    platform_win32=no
-    ;;
-esac
-AC_MSG_RESULT([$platform_win32])
-AM_CONDITIONAL(PLATFORM_WIN32, test "$platform_win32" = "yes")
-
-AC_MSG_CHECKING([for native Win32])
-case "$host" in
-  *-*-mingw*)
-    os_win32=yes
-    ;;
-  *)
-    os_win32=no
-    ;;
-esac
-AC_MSG_RESULT([$os_win32])
-AM_CONDITIONAL(OS_WIN32, test "$os_win32" = "yes")
-
 AC_DISABLE_STATIC
-AC_LIBTOOL_WIN32_DLL
 AC_PROG_LIBTOOL
 
 AL_PROG_GNU_M4(AC_MSG_ERROR([dnl
@@ -108,48 +81,25 @@ SUN make does not work for building gtkmm.
 Please install GNU make.]))
 
 #########################################################################
+#  Dependancy checks
+#########################################################################
+gtkmm_min_glib_version=2.6.0
+
+PKG_CHECK_MODULES(GLIBMM, glib-2.0 >= ${gtkmm_min_glib_version} gobject-2.0 >= ${gtkmm_min_glib_version} gmodule-2.0 >= ${gtkmm_min_glib_version})
+AC_SUBST(GLIBMM_CFLAGS)
+AC_SUBST(GLIBMM_LIBS)
+
+# gthread isn't a requirement, but we should use its CFLAGS if available.
+PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= ${gtkmm_min_glib_version},[],[GTHREAD_CFLAGS=''; GTHREAD_LIBS=''])
+AC_SUBST(GTHREAD_CFLAGS)
+AC_SUBST(GTHREAD_LIBS)
+
+
+#########################################################################
 #  C++ checks
 #########################################################################
 AC_PROG_CXX
 
-# Check for the SUN Forte compiler, and define GLIBMM_COMPILER_SUN_FORTE in the header.
-GLIBMM_PROG_CXX_SUN
-
-# Ensure MSVC-compatible struct packing convention is used when
-# compiling for Win32 with gcc.
-# What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
-# gcc2 uses "-fnative-struct".
-if test x"$os_win32" = xyes; then
-  if test x"$GCC" = xyes -a x"$GXX" = xyes; then
-    msnative_struct=''
-    AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
-    if test -z "$ac_cv_prog_CC"; then
-      our_gcc="$CC"
-    else
-      our_gcc="$ac_cv_prog_CC"
-    fi
-    case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
-      2.)
-	if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
-	  msnative_struct='-fnative-struct'
-	fi
-	;;
-      *)
-	if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
-	  msnative_struct='-mms-bitfields'
-	fi
-	;;
-    esac
-    if test x"$msnative_struct" = x ; then
-      AC_MSG_RESULT([no way])
-      AC_MSG_WARN([produced libraries might be incompatible with MSVC-compiled code])
-    else
-      CXXFLAGS="$CXXFLAGS $msnative_struct"
-      AC_MSG_RESULT([${msnative_struct}])
-    fi
-  fi
-fi
-
 AC_LANG_CPLUSPLUS
 
 AC_CXX_BOOL(,config_error=yes)
@@ -174,35 +124,12 @@ GLIBMM_CXX_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS()
 GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC()
 GLIBMM_CXX_ALLOWS_STATIC_INLINE_NPOS()
 
-
 # Check whether --enable-debug-refcounting was given.
 GLIBMM_ARG_ENABLE_DEBUG_REFCOUNTING()
 
 # Evaluate the --enable-warnings=level option.
 GTKMM_ARG_ENABLE_WARNINGS()
 
-# Add an --enable-use-deprecations configure option:
-AC_ARG_ENABLE(deprecations,
-              [AC_HELP_STRING([--enable-use-deprecations],
-                              [warn about deprecated usages [default=no]])],,
-              [enable_deprecations=no])
-              
-if test "x$enable_use_deprecations" = "xyes"; then
-   DISABLE_DEPRECATED_CFLAGS="-DG_DISABLE_DEPRECATED"
-   AC_SUBST(DISABLE_DEPRECATED_CFLAGS)
-fi
-
-#Offer the ability to omit some API from the library, 
-#to reduce the code size:
-GLIBMM_ARG_ENABLE_API_DEPRECATED()
-GLIBMM_ARG_ENABLE_API_EXCEPTIONS()
-GLIBMM_ARG_ENABLE_API_PROPERTIES()
-GLIBMM_ARG_ENABLE_API_VFUNCS()
-
-# Offer the ability to omit some API from the library, 
-# to reduce the code size:
-GLIBMM_ARG_ENABLE_API_DEFAULT_SIGNAL_HANDLERS()
-
 # Dummy conditional just to make automake-1.4 happy.
 # We need an always-false condition in docs/Makefile.am.
 AM_CONDITIONAL(GTKMM_FALSE,[false])
@@ -211,7 +138,6 @@ AM_CONDITIONAL(GTKMM_FALSE,[false])
 # maintainer-mode rules.  That would fail since we aren't using autoheader.
 AUTOHEADER=':'
 
-
 AC_CONFIG_FILES([
   Makefile
 
diff --git a/libs/glibmm2/glibmm/.cvsignore b/libs/glibmm2/glibmm/.cvsignore
new file mode 100644
index 0000000000..b18226c279
--- /dev/null
+++ b/libs/glibmm2/glibmm/.cvsignore
@@ -0,0 +1,3 @@
+Makefile
+Makefile.in
+*.os
diff --git a/libs/glibmm2/glibmm/Makefile.am b/libs/glibmm2/glibmm/Makefile.am
index 18e22651b3..ff8555c571 100644
--- a/libs/glibmm2/glibmm/Makefile.am
+++ b/libs/glibmm2/glibmm/Makefile.am
@@ -1,7 +1,7 @@
 ## Copyright (c) 2001
 ## The gtkmm development team.
 
-SUBDIRS = private
+SUBDIRS = 
 
 sublib_name = glibmm
 sublib_libname = glibmm-2.4
@@ -9,9 +9,8 @@ sublib_namespace = Glib
 sublib_cflags = $(GLIBMM_CFLAGS)
 
 sublib_files_extra_posix_cc =
-sublib_files_extra_win32_cc =
 
-sublib_files_extra_general_cc = \
+sublib_files_general_cc = \
   class.cc \
   containers.cc \
   debug.cc \
@@ -44,10 +43,9 @@ sublib_files_extra_general_cc = \
   value_custom.cc \
   wrap.cc
 
-sublib_files_extra_posix_h =
-sublib_files_extra_win32_h =
+sublib_files_posix_h =
 
-sublib_files_extra_general_h = \
+sublib_files_general_h = \
   arrayhandle.h \
   class.h \
   containerhandle_shared.h  \
@@ -92,11 +90,7 @@ files_built_general_cc  = value_basictypes.cc
 files_built_general_h  = signalproxy.h value_basictypes.h
 
 lib_LTLIBRARIES = libglibmm-2.4.la
-if OS_WIN32
-libglibmm_2_4_la_SOURCES = $(files_all_general_cc) $(files_all_win32_cc)
-else
 libglibmm_2_4_la_SOURCES = $(files_all_general_cc) $(files_all_posix_cc)
-endif
 libglibmm_2_4_la_LDFLAGS = $(common_ldflags)
 libglibmm_2_4_la_LIBADD = $(GLIBMM_LIBS)
 
diff --git a/libs/glibmm2/glibmm/class.cc b/libs/glibmm2/glibmm/class.cc
index be71fa46fd..ff4a671d8d 100644
--- a/libs/glibmm2/glibmm/class.cc
+++ b/libs/glibmm2/glibmm/class.cc
@@ -106,11 +106,10 @@ void Class::custom_class_init_function(void* g_class, void* class_data)
   // the vfunc and default signal handler callbacks.
   (*self->class_init_func_)(g_class, 0);
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
   GObjectClass *const gobject_class = static_cast<GObjectClass*>(g_class);
+
   gobject_class->get_property = &Glib::custom_get_property_callback;
   gobject_class->set_property = &Glib::custom_set_property_callback;
-#endif //GLIBMM_PROPERTIES_ENABLED
 }
 
 } // namespace Glib
diff --git a/libs/glibmm2/glibmm/class.h b/libs/glibmm2/glibmm/class.h
index 2610d758b6..c7b5a96fa7 100644
--- a/libs/glibmm2/glibmm/class.h
+++ b/libs/glibmm2/glibmm/class.h
@@ -23,7 +23,6 @@
  */
 
 #include <glib-object.h>
-#include <glibmmconfig.h> //Include this here so that the /private/*.h classes have access to GLIBMM_VFUNCS_ENABLED
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
diff --git a/libs/glibmm2/glibmm/containers.h b/libs/glibmm2/glibmm/containers.h
index f152262e6b..c7090681a3 100644
--- a/libs/glibmm2/glibmm/containers.h
+++ b/libs/glibmm2/glibmm/containers.h
@@ -178,7 +178,7 @@ public:
 
   reference operator*()  const
   {
-    //g++ complains that this statement has no effect: g_assert(node_);
+    g_assert(node_);
     return reinterpret_cast<T&>( node_ ? node_->data : glibmm_null_pointer );
   }
 
diff --git a/libs/glibmm2/glibmm/convert.cc b/libs/glibmm2/glibmm/convert.cc
index 7372bc72fc..1cd334bcd1 100644
--- a/libs/glibmm2/glibmm/convert.cc
+++ b/libs/glibmm2/glibmm/convert.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/convert.h>
 #include <glibmm/private/convert_p.h>
 
@@ -41,19 +40,17 @@ IConv::IConv(const std::string& to_codeset, const std::string& from_codeset)
 {
   if(gobject_ == reinterpret_cast<GIConv>(-1))
   {
-    GError* gerror = 0;
+    GError* error = 0;
 
     // Abuse g_convert() to create a GError object.  This may seem a weird
     // thing to do, but it gives us consistently translated error messages
     // at no further cost.
-    g_convert("", 0, to_codeset.c_str(), from_codeset.c_str(), 0, 0, &gerror);
+    g_convert("", 0, to_codeset.c_str(), from_codeset.c_str(), 0, 0, &error);
 
     // If this should ever fail we're fucked.
-    g_assert(gerror != 0);
+    g_assert(error != 0);
 
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    if(gerror) ::Glib::Error::throw_exception(gerror);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
+    Error::throw_exception(error);
   }
 }
 
@@ -85,23 +82,16 @@ void IConv::reset()
   g_iconv(gobject_, 0, &inbytes_left, &outbuf, &outbytes_left);
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string IConv::convert(const std::string& str)
-#else
-std::string IConv::convert(const std::string& str, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_convert_with_iconv(
-      str.data(), str.size(), gobject_, 0, &bytes_written, &gerror);
+      str.data(), str.size(), gobject_, 0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return std::string(ScopedPtr<char>(buf).get(), bytes_written);
 }
@@ -123,196 +113,125 @@ bool get_charset(std::string& charset)
   return is_utf8;
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string convert(const std::string& str,
                     const std::string& to_codeset,
                     const std::string& from_codeset)
-#else
-std::string convert(const std::string& str,
-                    const std::string& to_codeset,
-                    const std::string& from_codeset, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_convert(
       str.data(), str.size(), to_codeset.c_str(), from_codeset.c_str(),
-      0, &bytes_written, &gerror);
+      0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return std::string(ScopedPtr<char>(buf).get(), bytes_written);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string convert_with_fallback(const std::string& str,
                                   const std::string& to_codeset,
                                   const std::string& from_codeset)
-#else
-std::string convert_with_fallback(const std::string& str,
-                                  const std::string& to_codeset,
-                                  const std::string& from_codeset, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_convert_with_fallback(
       str.data(), str.size(), to_codeset.c_str(), from_codeset.c_str(), 0,
-      0, &bytes_written, &gerror);
+      0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return std::string(ScopedPtr<char>(buf).get(), bytes_written);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string convert_with_fallback(const std::string& str,
                                   const std::string& to_codeset,
                                   const std::string& from_codeset,
                                   const Glib::ustring& fallback)
-#else
-std::string convert_with_fallback(const std::string& str,
-                                  const std::string& to_codeset,
-                                  const std::string& from_codeset,
-                                  const Glib::ustring& fallback, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_convert_with_fallback(
       str.data(), str.size(), to_codeset.c_str(), from_codeset.c_str(),
-      const_cast<char*>(fallback.c_str()), 0, &bytes_written, &gerror);
+      const_cast<char*>(fallback.c_str()), 0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return std::string(ScopedPtr<char>(buf).get(), bytes_written);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring locale_to_utf8(const std::string& opsys_string)
-#else
-Glib::ustring locale_to_utf8(const std::string& opsys_string, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_locale_to_utf8(
-      opsys_string.data(), opsys_string.size(), 0, &bytes_written, &gerror);
+      opsys_string.data(), opsys_string.size(), 0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   const ScopedPtr<char> scoped_buf (buf);
   return Glib::ustring(scoped_buf.get(), scoped_buf.get() + bytes_written);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string locale_from_utf8(const Glib::ustring& utf8_string)
-#else
-std::string locale_from_utf8(const Glib::ustring& utf8_string, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_locale_from_utf8(
-      utf8_string.data(), utf8_string.bytes(), 0, &bytes_written, &gerror);
+      utf8_string.data(), utf8_string.bytes(), 0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return std::string(ScopedPtr<char>(buf).get(), bytes_written);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring filename_to_utf8(const std::string& opsys_string)
-#else
-Glib::ustring filename_to_utf8(const std::string& opsys_string, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_filename_to_utf8(
-      opsys_string.data(), opsys_string.size(), 0, &bytes_written, &gerror);
+      opsys_string.data(), opsys_string.size(), 0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   const ScopedPtr<char> scoped_buf (buf);
   return Glib::ustring(scoped_buf.get(), scoped_buf.get() + bytes_written);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string filename_from_utf8(const Glib::ustring& utf8_string)
-#else
-std::string filename_from_utf8(const Glib::ustring& utf8_string, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
   char *const buf = g_filename_from_utf8(
-      utf8_string.data(), utf8_string.bytes(), 0, &bytes_written, &gerror);
+      utf8_string.data(), utf8_string.bytes(), 0, &bytes_written, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return std::string(ScopedPtr<char>(buf).get(), bytes_written);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string filename_from_uri(const Glib::ustring& uri, Glib::ustring& hostname)
-#else
-std::string filename_from_uri(const Glib::ustring& uri, Glib::ustring& hostname, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   char* hostname_buf = 0;
-  GError* gerror = 0;
+  GError* error = 0;
 
-  char *const buf = g_filename_from_uri(uri.c_str(), &hostname_buf, &gerror);
+  char *const buf = g_filename_from_uri(uri.c_str(), &hostname_buf, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   // Let's take ownership at this point.
   const ScopedPtr<char> scoped_buf (buf);
@@ -325,59 +244,35 @@ std::string filename_from_uri(const Glib::ustring& uri, Glib::ustring& hostname,
   return std::string(scoped_buf.get());
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string filename_from_uri(const Glib::ustring& uri)
-#else
-std::string filename_from_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
-  char *const buf = g_filename_from_uri(uri.c_str(), 0, &gerror);
+  GError* error = 0;
+  char *const buf = g_filename_from_uri(uri.c_str(), 0, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return std::string(ScopedPtr<char>(buf).get());
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring filename_to_uri(const std::string& filename, const Glib::ustring& hostname)
-#else
-Glib::ustring filename_to_uri(const std::string& filename, const Glib::ustring& hostname, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
-  char *const buf = g_filename_to_uri(filename.c_str(), hostname.c_str(), &gerror);
+  GError* error = 0;
+  char *const buf = g_filename_to_uri(filename.c_str(), hostname.c_str(), &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return Glib::ustring(ScopedPtr<char>(buf).get());
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring filename_to_uri(const std::string& filename)
-#else
-Glib::ustring filename_to_uri(const std::string& filename, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
-  char *const buf = g_filename_to_uri(filename.c_str(), 0, &gerror);
+  GError* error = 0;
+  char *const buf = g_filename_to_uri(filename.c_str(), 0, &error);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror) ::Glib::Error::throw_exception(gerror);
-  #else
-  if(gerror) error = ::Glib::Error::throw_exception(gerror);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Error::throw_exception(error);
 
   return Glib::ustring(ScopedPtr<char>(buf).get());
 }
@@ -420,17 +315,9 @@ Glib::ConvertError::Code Glib::ConvertError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::ConvertError::throw_func(GError* gobject)
 {
   throw Glib::ConvertError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::ConvertError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::ConvertError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
diff --git a/libs/glibmm2/glibmm/convert.h b/libs/glibmm2/glibmm/convert.h
index 69549cde6a..335624f0ff 100644
--- a/libs/glibmm2/glibmm/convert.h
+++ b/libs/glibmm2/glibmm/convert.h
@@ -67,14 +67,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
@@ -126,11 +119,7 @@ public:
    * @return The converted string.
    * @throw Glib::ConvertError
    */
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   std::string convert(const std::string& str);
-  #else
-  std::string convert(const std::string& str, std::auto_ptr<Glib::Error>& error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   GIConv gobj() { return gobject_; }
 
@@ -161,15 +150,9 @@ bool get_charset(std::string& charset);
  * @return The converted string.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string convert(const std::string& str,
                     const std::string& to_codeset,
                     const std::string& from_codeset);
-#else
-std::string convert(const std::string& str,
-                    const std::string& to_codeset,
-                    const std::string& from_codeset, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts a string from one character set to another, possibly including
  * fallback sequences for characters not representable in the output.
@@ -181,15 +164,9 @@ std::string convert(const std::string& str,
  * @return The converted string.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string convert_with_fallback(const std::string& str,
                                   const std::string& to_codeset,
                                   const std::string& from_codeset);
-#else
-std::string convert_with_fallback(const std::string& str,
-                                  const std::string& to_codeset,
-                                  const std::string& from_codeset, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts a string from one character set to another, possibly including
  * fallback sequences for characters not representable in the output.
@@ -207,17 +184,10 @@ std::string convert_with_fallback(const std::string& str,
  * @return The converted string.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string convert_with_fallback(const std::string& str,
                                   const std::string& to_codeset,
                                   const std::string& from_codeset,
                                   const Glib::ustring& fallback);
-#else
-std::string convert_with_fallback(const std::string& str,
-                                  const std::string& to_codeset,
-                                  const std::string& from_codeset,
-                                  const Glib::ustring& fallback, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Convert from the current locale's encoding to UTF-8.
  * Convenience wrapper around Glib::convert().
@@ -226,11 +196,7 @@ std::string convert_with_fallback(const std::string& str,
  * @return The input string converted to UTF-8 encoding.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring locale_to_utf8(const std::string& opsys_string);
-#else
-Glib::ustring locale_to_utf8(const std::string& opsys_string, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Convert from UTF-8 to the current locale's encoding.
  * Convenience wrapper around Glib::convert().
@@ -239,11 +205,7 @@ Glib::ustring locale_to_utf8(const std::string& opsys_string, std::auto_ptr<Glib
  *  system's current locale.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string locale_from_utf8(const Glib::ustring& utf8_string);
-#else
-std::string locale_from_utf8(const Glib::ustring& utf8_string, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts a string which is in the encoding used for filenames into
  * a UTF-8 string.
@@ -251,22 +213,14 @@ std::string locale_from_utf8(const Glib::ustring& utf8_string, std::auto_ptr<Gli
  * @return The converted string.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring filename_to_utf8(const std::string& opsys_string);
-#else
-Glib::ustring filename_to_utf8(const std::string& opsys_string, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts a string from UTF-8 to the encoding used for filenames.
  * @param utf8_string A UTF-8 encoded string.
  * @return The converted string.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string filename_from_utf8(const Glib::ustring& utf8_string);
-#else
-std::string filename_from_utf8(const Glib::ustring& utf8_string, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts an escaped UTF-8 encoded URI to a local filename
  * in the encoding used for filenames.
@@ -276,11 +230,7 @@ std::string filename_from_utf8(const Glib::ustring& utf8_string, std::auto_ptr<G
  * @return The resulting filename.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string filename_from_uri(const Glib::ustring& uri, Glib::ustring& hostname);
-#else
-std::string filename_from_uri(const Glib::ustring& uri, Glib::ustring& hostname, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts an escaped UTF-8 encoded URI to a local filename in the encoding
  * used for filenames.
@@ -288,11 +238,7 @@ std::string filename_from_uri(const Glib::ustring& uri, Glib::ustring& hostname,
  * @return The resulting filename.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 std::string filename_from_uri(const Glib::ustring& uri);
-#else
-std::string filename_from_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts an absolute filename to an escaped UTF-8 encoded URI.
  * @param filename An absolute filename specified in the encoding used
@@ -301,11 +247,7 @@ std::string filename_from_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Erro
  * @return The resulting URI.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring filename_to_uri(const std::string& filename, const Glib::ustring& hostname);
-#else
-Glib::ustring filename_to_uri(const std::string& filename, const Glib::ustring& hostname, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Converts an absolute filename to an escaped UTF-8 encoded URI.
  * @param filename An absolute filename specified in the encoding used
@@ -313,11 +255,7 @@ Glib::ustring filename_to_uri(const std::string& filename, const Glib::ustring&
  * @return The resulting URI.
  * @throw Glib::ConvertError
  */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::ustring filename_to_uri(const std::string& filename);
-#else
-Glib::ustring filename_to_uri(const std::string& filename, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 /** Returns the display basename for the particular filename, guaranteed
  * to be valid UTF-8. The display name might not be identical to the filename,
@@ -350,7 +288,7 @@ Glib::ustring filename_display_basename(const std::string& filename);
  * @param filename: a pathname hopefully in the GLib file name encoding
  * @result A string containing a rendition of the filename in valid UTF-8.
  */
-Glib::ustring filename_display_name(const std::string& filename);
+Glib::ustring filename_display_name(const Glib::ustring& filename);
 
 /** @} group CharsetConv */
 
diff --git a/libs/glibmm2/glibmm/date.cc b/libs/glibmm2/glibmm/date.cc
index eb829aedb2..8058376e2a 100644
--- a/libs/glibmm2/glibmm/date.cc
+++ b/libs/glibmm2/glibmm/date.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/date.h>
 #include <glibmm/private/date_p.h>
 
@@ -29,13 +28,13 @@
 
 #include <ctime>
 #include <algorithm>
-
 #include <glibmm/convert.h>
 #include <glibmm/utility.h>
 
 #include <glibmmconfig.h>
 GLIBMM_USING_STD(max)
 
+
 namespace Glib
 {
 
@@ -71,31 +70,10 @@ void Date::set_parse(const Glib::ustring& str)
   g_date_set_parse(&gobject_, str.c_str());
 }
 
-#ifndef GLIBMM_DISABLE_DEPRECATED
-
 void Date::set_time(GTime time)
 {
-  //This method, and the C function that it wraps, are deprecated.
   g_date_set_time(&gobject_, time);
 }
-#endif // GLIBMM_DISABLE_DEPRECATED
-
-
-void Date::set_time(time_t timet)
-{
-  g_date_set_time_t(&gobject_, timet);
-}
-
-void Date::set_time_current()
-{
-  //As suggested in the C documentation:
-  g_date_set_time_t(&gobject_, time(NULL));
-}
-
-void Date::set_time(const GTimeVal& timeval)
-{
-  g_date_set_time_val(&gobject_, const_cast<GTimeVal*>(&timeval));
-}
 
 void Date::set_month(Date::Month month)
 {
@@ -288,13 +266,7 @@ Glib::ustring Date::format_string(const Glib::ustring& format) const
   struct tm tm_data;
   g_date_to_struct_tm(&gobject_, &tm_data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   const std::string locale_format = locale_from_utf8(format);
-  #else
-  std::auto_ptr<Glib::Error> error; //TODO: Check it?
-  const std::string locale_format = locale_from_utf8(format, error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
   gsize bufsize = std::max<gsize>(2 * locale_format.size(), 128);
 
   do
@@ -309,12 +281,7 @@ Glib::ustring Date::format_string(const Glib::ustring& format) const
     if(len != 0 || buf.get()[0] == '\0')
     {
       g_assert(len < bufsize);
-      #ifdef GLIBMM_EXCEPTIONS_ENABLED
       return locale_to_utf8(std::string(buf.get(), len));
-      #else
-      std::auto_ptr<Glib::Error> error; //TODO: Check it?
-      return locale_to_utf8(std::string(buf.get(), len), error);
-      #endif //GLIBMM_EXCEPTIONS_ENABLED
     }
   }
   while((bufsize *= 2) <= 65536);
diff --git a/libs/glibmm2/glibmm/date.h b/libs/glibmm2/glibmm/date.h
index 917bd78f6b..341a641b1a 100644
--- a/libs/glibmm2/glibmm/date.h
+++ b/libs/glibmm2/glibmm/date.h
@@ -24,8 +24,6 @@
  */
 
 
-  #undef G_DISABLE_DEPRECATED //So we can use deprecated functions in our deprecated methods.
- 
 #include <glibmm/ustring.h>
 
 #include <glib/gdate.h>
@@ -35,6 +33,7 @@
 extern "C" { struct tm; }
 #endif
 
+
 namespace Glib
 {
 
@@ -119,41 +118,15 @@ enum DMY
    */
   void set_parse (const Glib::ustring& str);
 
-  #ifndef GLIBMM_DISABLE_DEPRECATED
-
+  //TODO: Add set_time_current() - see the docs comment below.?
   /** Sets the value of a date from a GTime (time_t) value. 
+   * To set the value of a date to the current day, you could write:
    *
-   * @param time GTime value to set.
+   *set_time(time(NULL));
    *
-   * @deprecated Please use set_time(time_t) or set_time(const GTimeVal&).
+   * @param time GTime value to set.
    */
   void set_time(GTime time);
-  #endif // GLIBMM_DISABLE_DEPRECATED
-
-
-  /** Sets the value of a date from a <type>time_t</type> value. 
-   *
-   * @param timet time_t value to set
-   *
-   * @see set_time_current()
-   *
-   * Since: 2.10
-   */
-  void set_time(time_t timet);
-
-  /** Sets the value of a date from a GTimeVal value.  Note that the
-   * tv_usec member is ignored, because Glib::Date can't make use of the
-   * additional precision.
-   *
-   * @see set_time_current()
-   * 
-   * @param timeval GTimeVal value to set
-   *
-   * Since: 2.10
-   */
-  void set_time(const GTimeVal& timeval);
-
-  void set_time_current();
 
   /** Sets the month of the year. If the resulting day-month-year triplet is invalid, the date will be invalid.
    * @param month Month to set.
diff --git a/libs/glibmm2/glibmm/dispatcher.cc b/libs/glibmm2/glibmm/dispatcher.cc
index 2860912975..15c63ae322 100644
--- a/libs/glibmm2/glibmm/dispatcher.cc
+++ b/libs/glibmm2/glibmm/dispatcher.cc
@@ -129,7 +129,7 @@ static void fd_close_and_invalidate(int& fd)
 namespace Glib
 {
 
-class DispatchNotifier : public sigc::trackable
+class DispatchNotifier
 {
 public:
   ~DispatchNotifier();
@@ -188,10 +188,8 @@ DispatchNotifier::DispatchNotifier(const Glib::RefPtr<MainContext>& context)
 {
   create_pipe();
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 #ifdef G_OS_WIN32
     conn_io_handler_ = context_->signal_io().connect(
         sigc::mem_fun(*this, &DispatchNotifier::pipe_io_handler),
@@ -201,7 +199,6 @@ DispatchNotifier::DispatchNotifier(const Glib::RefPtr<MainContext>& context)
         sigc::mem_fun(*this, &DispatchNotifier::pipe_io_handler),
         fd_receiver_, Glib::IO_IN);
 #endif /* !G_OS_WIN32 */
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
@@ -212,7 +209,6 @@ DispatchNotifier::DispatchNotifier(const Glib::RefPtr<MainContext>& context)
 
     throw;
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 DispatchNotifier::~DispatchNotifier()
@@ -235,29 +231,20 @@ void DispatchNotifier::create_pipe()
 
   if(!fd_receiver_)
   {
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
     GError* const error = g_error_new(G_FILE_ERROR, G_FILE_ERROR_FAILED,
                                       "Failed to create event for inter-thread communication: %s",
                                       g_win32_error_message(GetLastError()));
     throw Glib::FileError(error);
-#else 
-    return; //TODO: Provide an alternative to the exception.
-#endif //GLIBMM_EXCEPTIONS_ENABLED
   }
-
 #else /* !G_OS_WIN32 */
   int filedes[2] = { -1, -1 };
 
   if(pipe(filedes) < 0)
   {
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
     GError* const error = g_error_new(G_FILE_ERROR, g_file_error_from_errno(errno),
                                       "Failed to create pipe for inter-thread communication: %s",
                                       g_strerror(errno));
     throw Glib::FileError(error);
-#else 
-    return; //TODO: Provide an alternative to the exception.
-#endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   fd_set_close_on_exec(filedes[0]);
@@ -366,18 +353,14 @@ bool DispatchNotifier::pipe_io_handler(Glib::IOCondition)
     // Actually, we wouldn't need the try/catch block because the Glib::Source
     // C callback already does it for us.  However, we do it anyway because the
     // default return value is 'false', which is not what we want.
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       data.dispatcher->signal_();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 #else /* !G_OS_WIN32 */
   DispatchNotifyData data;
@@ -407,18 +390,14 @@ bool DispatchNotifier::pipe_io_handler(Glib::IOCondition)
   // Actually, we wouldn't need the try/catch block because the Glib::Source
   // C callback already does it for us.  However, we do it anyway because the
   // default return value is 'false', which is not what we want.
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     data.dispatcher->signal_(); // emit
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 #endif /* !G_OS_WIN32 */
 
   return true;
diff --git a/libs/glibmm2/glibmm/dispatcher.h b/libs/glibmm2/glibmm/dispatcher.h
index 3cfa754d74..cecf606eeb 100644
--- a/libs/glibmm2/glibmm/dispatcher.h
+++ b/libs/glibmm2/glibmm/dispatcher.h
@@ -67,7 +67,6 @@ public:
    * @throw Glib::FileError
    */
   Dispatcher();
-  
   /** Create new Dispatcher instance using an arbitrary main context.
    * @throw Glib::FileError
    */
diff --git a/libs/glibmm2/glibmm/error.cc b/libs/glibmm2/glibmm/error.cc
index fea6d66076..2e8f072322 100644
--- a/libs/glibmm2/glibmm/error.cc
+++ b/libs/glibmm2/glibmm/error.cc
@@ -30,6 +30,7 @@
 
 GLIBMM_USING_STD(map)
 
+
 namespace
 {
 
@@ -130,6 +131,7 @@ void Error::propagate(GError** dest)
   gobject_ = 0;
 }
 
+
 // static
 void Error::register_init()
 {
@@ -158,12 +160,8 @@ void Error::register_domain(GQuark domain, Error::ThrowFunc throw_func)
   (*throw_func_table)[domain] = throw_func;
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 // static, noreturn
 void Error::throw_exception(GError* gobject)
-#else
-std::auto_ptr<Glib::Error> Error::throw_exception(GError* gobject)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   g_assert(gobject != 0);
 
@@ -173,11 +171,7 @@ std::auto_ptr<Glib::Error> Error::throw_exception(GError* gobject)
 
   if(const ThrowFunc throw_func = (*throw_func_table)[gobject->domain])
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     (*throw_func)(gobject);
-    #else
-    return (*throw_func)(gobject);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
     g_assert_not_reached();
   }
 
@@ -185,14 +179,9 @@ std::auto_ptr<Glib::Error> Error::throw_exception(GError* gobject)
             "unknown error domain '%s': throwing generic Glib::Error exception\n",
             (gobject->domain) ? g_quark_to_string(gobject->domain) : "(null)");
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   // Doesn't copy, because error-returning functions return a newly allocated GError for us.
   throw Glib::Error(gobject);
-#else
-  return std::auto_ptr<Glib::Error>(new Glib::Error(gobject));
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-
 } // namespace Glib
 
diff --git a/libs/glibmm2/glibmm/error.h b/libs/glibmm2/glibmm/error.h
index df382fb995..d4c39e6d80 100644
--- a/libs/glibmm2/glibmm/error.h
+++ b/libs/glibmm2/glibmm/error.h
@@ -26,12 +26,6 @@ extern "C" { typedef struct _GError GError; }
 
 #include <glib/gquark.h>
 #include <glibmm/exception.h>
-#include <glibmmconfig.h> //For GLIBMM_EXCEPTIONS_ENABLED
-
-#ifndef GLIBMM_EXCEPTIONS_ENABLED
-//When not usinge exceptions, we pass auto_ptrs of the exceptions objects around instead. 
-#include <memory> //For std::auto_ptr
-#endif
 
 
 namespace Glib
@@ -62,22 +56,13 @@ public:
 
   void propagate(GError** dest);
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   typedef void (* ThrowFunc) (GError*);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  typedef std::auto_ptr<Glib::Error> (* ThrowFunc) (GError*);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
   static void register_init();
   static void register_cleanup();
   static void register_domain(GQuark domain, ThrowFunc throw_func);
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_exception(GError* gobject) G_GNUC_NORETURN;
-#else
-  static std::auto_ptr<Glib::Error> throw_exception(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
diff --git a/libs/glibmm2/glibmm/exceptionhandler.cc b/libs/glibmm2/glibmm/exceptionhandler.cc
index c879972ab8..cfe6892483 100644
--- a/libs/glibmm2/glibmm/exceptionhandler.cc
+++ b/libs/glibmm2/glibmm/exceptionhandler.cc
@@ -32,7 +32,6 @@
 GLIBMM_USING_STD(exception)
 GLIBMM_USING_STD(list)
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 
 namespace
 {
@@ -158,6 +157,3 @@ void exception_handlers_invoke() throw()
 
 } // namespace Glib
 
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-
diff --git a/libs/glibmm2/glibmm/exceptionhandler.h b/libs/glibmm2/glibmm/exceptionhandler.h
index 03079399e4..de1d68f48c 100644
--- a/libs/glibmm2/glibmm/exceptionhandler.h
+++ b/libs/glibmm2/glibmm/exceptionhandler.h
@@ -24,9 +24,7 @@
  */
 
 #include <sigc++/sigc++.h>
-#include <glibmmconfig.h>
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 
 namespace Glib
 {
@@ -42,7 +40,6 @@ void exception_handlers_invoke() throw();
 
 } // namespace Glib
 
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 #endif /* _GLIBMM_EXCEPTIONHANDLER_H */
 
diff --git a/libs/glibmm2/glibmm/fileutils.cc b/libs/glibmm2/glibmm/fileutils.cc
index 2dd5ca2b71..ce7051faa0 100644
--- a/libs/glibmm2/glibmm/fileutils.cc
+++ b/libs/glibmm2/glibmm/fileutils.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/fileutils.h>
 #include <glibmm/private/fileutils_p.h>
 
@@ -210,17 +209,9 @@ Glib::FileError::Code Glib::FileError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::FileError::throw_func(GError* gobject)
 {
   throw Glib::FileError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::FileError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::FileError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
diff --git a/libs/glibmm2/glibmm/fileutils.h b/libs/glibmm2/glibmm/fileutils.h
index 6c427f8ec7..67f1106a64 100644
--- a/libs/glibmm2/glibmm/fileutils.h
+++ b/libs/glibmm2/glibmm/fileutils.h
@@ -137,14 +137,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
diff --git a/libs/glibmm2/glibmm/iochannel.cc b/libs/glibmm2/glibmm/iochannel.cc
index 3c49fb12d5..18e434da7a 100644
--- a/libs/glibmm2/glibmm/iochannel.cc
+++ b/libs/glibmm2/glibmm/iochannel.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/iochannel.h>
 #include <glibmm/private/iochannel_p.h>
 
@@ -177,23 +176,13 @@ IOChannel::~IOChannel()
   }
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::RefPtr<IOChannel> IOChannel::create_from_file(const std::string& filename, const std::string& mode)
-#else
-Glib::RefPtr<IOChannel> IOChannel::create_from_file(const std::string& filename, const std::string& mode, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
-  GIOChannel *const channel = g_io_channel_new_file(filename.c_str(), mode.c_str(), &gerror);
+  GError* error = 0;
+  GIOChannel *const channel = g_io_channel_new_file(filename.c_str(), mode.c_str(), &error);
 
-  if(gerror)
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    Glib::Error::throw_exception(gerror);
-    #else
-    error = Glib::Error::throw_exception(gerror);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
+  if(error)
+    Glib::Error::throw_exception(error);
 
   return Glib::wrap(channel, false);
 }
@@ -217,40 +206,22 @@ Glib::RefPtr<IOChannel> IOChannel::create_from_win32_socket(int socket)
 
 #endif /* G_OS_WIN32 */
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::write(const Glib::ustring& str)
-#else
-IOStatus IOChannel::write(const Glib::ustring& str, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   gsize bytes_written = 0;
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   return write(str.data(), str.bytes(), bytes_written);
-#else
-  return write(str.data(), str.bytes(), bytes_written, error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::read_line(Glib::ustring& line)
-#else
-IOStatus IOChannel::read_line(Glib::ustring& line, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   Glib::ScopedPtr<char> buf;
-  GError* gerror = 0;
+  GError* error = 0;
   gsize   bytes = 0;
 
-  const GIOStatus status = g_io_channel_read_line(gobj(), buf.addr(), &bytes, 0, &gerror);
+  const GIOStatus status = g_io_channel_read_line(gobj(), buf.addr(), &bytes, 0, &error);
 
-  if(gerror)
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    Glib::Error::throw_exception(gerror);
-    #else
-    error = Glib::Error::throw_exception(gerror);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
+  if(error)
+    Glib::Error::throw_exception(error);
 
   if(buf.get())
     line.assign(buf.get(), buf.get() + bytes);
@@ -260,26 +231,16 @@ IOStatus IOChannel::read_line(Glib::ustring& line, std::auto_ptr<Glib::Error>& e
   return (IOStatus) status;
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::read_to_end(Glib::ustring& str)
-#else
-IOStatus IOChannel::read_to_end(Glib::ustring& str, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   Glib::ScopedPtr<char> buf;
-  GError* gerror = 0;
+  GError* error = 0;
   gsize   bytes = 0;
 
-  const GIOStatus status = g_io_channel_read_to_end(gobj(), buf.addr(), &bytes, &gerror);
+  const GIOStatus status = g_io_channel_read_to_end(gobj(), buf.addr(), &bytes, &error);
 
-  if(gerror)
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    Glib::Error::throw_exception(gerror);
-    #else
-    error = Glib::Error::throw_exception(gerror);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
+  if(error)
+    Glib::Error::throw_exception(error);
 
   if(buf.get())
     str.assign(buf.get(), buf.get() + bytes);
@@ -289,26 +250,16 @@ IOStatus IOChannel::read_to_end(Glib::ustring& str, std::auto_ptr<Glib::Error>&
   return (IOStatus) status;
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::read(Glib::ustring& str, gsize count)
-#else
-IOStatus IOChannel::read(Glib::ustring& str, gsize count, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   Glib::ScopedPtr<char> buf (g_new(char, count));
-  GError* gerror = 0;
+  GError* error = 0;
   gsize   bytes = 0;
 
-  const GIOStatus status = g_io_channel_read_chars(gobj(), buf.get(), count, &bytes, &gerror);
+  const GIOStatus status = g_io_channel_read_chars(gobj(), buf.get(), count, &bytes, &error);
 
- if(gerror)
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    Glib::Error::throw_exception(gerror);
-    #else
-    error = Glib::Error::throw_exception(gerror);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
+  if(error)
+    Glib::Error::throw_exception(error);
 
   if(buf.get())
     str.assign(buf.get(), buf.get() + bytes);
@@ -318,25 +269,15 @@ IOStatus IOChannel::read(Glib::ustring& str, gsize count, std::auto_ptr<Glib::Er
   return (IOStatus) status;
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::set_encoding(const std::string& encoding)
-#else
-IOStatus IOChannel::set_encoding(const std::string& encoding, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
+  GError* error = 0;
 
   const GIOStatus status = g_io_channel_set_encoding(
-      gobj(), (encoding.empty()) ? 0 : encoding.c_str(), &gerror);
+      gobj(), (encoding.empty()) ? 0 : encoding.c_str(), &error);
 
-  if(gerror)
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    Glib::Error::throw_exception(gerror);
-    #else
-    error = Glib::Error::throw_exception(gerror);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
+  if(error)
+    Glib::Error::throw_exception(error);
 
   return (IOStatus) status;
 }
@@ -453,16 +394,11 @@ Glib::RefPtr<IOChannel> wrap(GIOChannel* gobject, bool take_copy)
 GIOStatus GlibmmIOChannel::io_read(GIOChannel* channel, char* buf, gsize count,
                                    gsize* bytes_read, GError** err)
 {
-  if(!&err) err = err; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return (GIOStatus) wrapper->read_vfunc(buf, count, *bytes_read);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(Glib::Error& error)
   {
@@ -472,7 +408,6 @@ GIOStatus GlibmmIOChannel::io_read(GIOChannel* channel, char* buf, gsize count,
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return G_IO_STATUS_ERROR;
 }
@@ -481,16 +416,11 @@ GIOStatus GlibmmIOChannel::io_read(GIOChannel* channel, char* buf, gsize count,
 GIOStatus GlibmmIOChannel::io_write(GIOChannel* channel, const char* buf, gsize count,
                                     gsize* bytes_written, GError** err)
 {
-  if(!&err) err = err; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return (GIOStatus) wrapper->write_vfunc(buf, count, *bytes_written);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(Glib::Error& error)
   {
@@ -500,7 +430,6 @@ GIOStatus GlibmmIOChannel::io_write(GIOChannel* channel, const char* buf, gsize
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return G_IO_STATUS_ERROR;
 }
@@ -508,16 +437,11 @@ GIOStatus GlibmmIOChannel::io_write(GIOChannel* channel, const char* buf, gsize
 // static
 GIOStatus GlibmmIOChannel::io_seek(GIOChannel* channel, gint64 offset, GSeekType type, GError** err)
 {
-  if(!&err) err = err; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return (GIOStatus) wrapper->seek_vfunc(offset, (SeekType) type);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(Glib::Error& error)
   {
@@ -527,7 +451,6 @@ GIOStatus GlibmmIOChannel::io_seek(GIOChannel* channel, gint64 offset, GSeekType
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return G_IO_STATUS_ERROR;
 }
@@ -535,16 +458,11 @@ GIOStatus GlibmmIOChannel::io_seek(GIOChannel* channel, gint64 offset, GSeekType
 // static
 GIOStatus GlibmmIOChannel::io_close(GIOChannel* channel, GError** err)
 {
-  if(!&err) err = err; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return (GIOStatus) wrapper->close_vfunc();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(Glib::Error& error)
   {
@@ -554,8 +472,6 @@ GIOStatus GlibmmIOChannel::io_close(GIOChannel* channel, GError** err)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
- 
 
   return G_IO_STATUS_ERROR;
 }
@@ -565,19 +481,15 @@ GSource* GlibmmIOChannel::io_create_watch(GIOChannel* channel, GIOCondition cond
 {
   IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     const Glib::RefPtr<Source> source = wrapper->create_watch_vfunc((IOCondition) condition);
     return (source) ? source->gobj_copy() : 0;
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return 0;
 }
@@ -597,16 +509,11 @@ void GlibmmIOChannel::io_free(GIOChannel* channel)
 // static
 GIOStatus GlibmmIOChannel::io_set_flags(GIOChannel* channel, GIOFlags flags, GError** err)
 {
-  if(!&err) err = err; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return (GIOStatus) wrapper->set_flags_vfunc((IOFlags) flags);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(Glib::Error& error)
   {
@@ -616,7 +523,6 @@ GIOStatus GlibmmIOChannel::io_set_flags(GIOChannel* channel, GIOFlags flags, GEr
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return G_IO_STATUS_ERROR;
 }
@@ -626,18 +532,14 @@ GIOFlags GlibmmIOChannel::io_get_flags(GIOChannel* channel)
 {
   IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return (GIOFlags) wrapper->get_flags_vfunc();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return GIOFlags(0);
 }
@@ -665,162 +567,70 @@ Glib::IOChannelError::Code Glib::IOChannelError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::IOChannelError::throw_func(GError* gobject)
 {
   throw Glib::IOChannelError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::IOChannelError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::IOChannelError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
 namespace Glib
 {
 
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::read(gunichar& unichar)
-#else
-IOStatus IOChannel::read(gunichar& unichar, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_read_unichar(gobj(), &(unichar), &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_read_unichar(gobj(), &(unichar), &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::read(char* buf, gsize count, gsize& bytes_read)
-#else
-IOStatus IOChannel::read(char* buf, gsize count, gsize& bytes_read, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_read_chars(gobj(), buf, count, &(bytes_read), &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_read_chars(gobj(), buf, count, &(bytes_read), &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::write(const char* buf, gssize count, gsize& bytes_written)
-#else
-IOStatus IOChannel::write(const char* buf, gssize count, gsize& bytes_written, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_write_chars(gobj(), buf, count, &(bytes_written), &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_write_chars(gobj(), buf, count, &(bytes_written), &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::write(gunichar unichar)
-#else
-IOStatus IOChannel::write(gunichar unichar, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_write_unichar(gobj(), unichar, &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_write_unichar(gobj(), unichar, &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::seek(gint64 offset, SeekType type)
-#else
-IOStatus IOChannel::seek(gint64 offset, SeekType type, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_seek_position(gobj(), offset, ((GSeekType)(type)), &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_seek_position(gobj(), offset, ((GSeekType)(type)), &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::flush()
-#else
-IOStatus IOChannel::flush(std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_flush(gobj(), &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_flush(gobj(), &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::close(bool flush)
-#else
-IOStatus IOChannel::close(bool flush, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_shutdown(gobj(), static_cast<int>(flush), &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_shutdown(gobj(), static_cast<int>(flush), &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
 gsize IOChannel::get_buffer_size() const
@@ -830,7 +640,7 @@ gsize IOChannel::get_buffer_size() const
 
 void IOChannel::set_buffer_size(gsize size)
 {
-g_io_channel_set_buffer_size(gobj(), size); 
+  g_io_channel_set_buffer_size(gobj(), size);
 }
 
 IOFlags IOChannel::get_flags() const
@@ -838,29 +648,17 @@ IOFlags IOChannel::get_flags() const
   return ((IOFlags)(g_io_channel_get_flags(const_cast<GIOChannel*>(gobj()))));
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 IOStatus IOChannel::set_flags(IOFlags flags)
-#else
-IOStatus IOChannel::set_flags(IOFlags flags, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  IOStatus retvalue = ((IOStatus)(g_io_channel_set_flags(gobj(), ((GIOFlags)(flags)), &(gerror))));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  IOStatus retvalue = ((IOStatus)(g_io_channel_set_flags(gobj(), ((GIOFlags)(flags)), &(error))));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
 void IOChannel::set_buffered(bool buffered)
 {
-g_io_channel_set_buffered(gobj(), static_cast<int>(buffered)); 
+  g_io_channel_set_buffered(gobj(), static_cast<int>(buffered));
 }
 
 bool IOChannel::get_buffered() const
@@ -880,7 +678,7 @@ bool IOChannel::get_close_on_unref() const
 
 void IOChannel::set_close_on_unref(bool do_close)
 {
-g_io_channel_set_close_on_unref(gobj(), static_cast<int>(do_close)); 
+  g_io_channel_set_close_on_unref(gobj(), static_cast<int>(do_close));
 }
 
 
diff --git a/libs/glibmm2/glibmm/iochannel.h b/libs/glibmm2/glibmm/iochannel.h
index f9e36ee940..3d8f93b3a7 100644
--- a/libs/glibmm2/glibmm/iochannel.h
+++ b/libs/glibmm2/glibmm/iochannel.h
@@ -147,14 +147,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
@@ -209,11 +202,7 @@ public:
    * @return An IOChannel for the opened file.
    * @throw Glib::FileError
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static Glib::RefPtr<IOChannel> create_from_file(const std::string& filename, const std::string& mode);
-#else
-  static Glib::RefPtr<IOChannel> create_from_file(const std::string& filename, const std::string& mode, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
   
 
   /** Creates an I/O channel from a file descriptor.
@@ -275,12 +264,7 @@ public:
    * or G::IOChannelError.
    * @return A G::IOStatus.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus read(gunichar& unichar);
-#else
-  IOStatus read(gunichar& unichar, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Read a character sequence into memory.
    * @param buf A buffer to read data into.
@@ -309,12 +293,7 @@ public:
    * or G::IOChannelError.
    * @return The status of the operation.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus read(char* buf, gsize count, gsize& bytes_read);
-#else
-  IOStatus read(char* buf, gsize count, gsize& bytes_read, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Read a maximum of @a count bytes into @a str.
    * @param count The maximum number of bytes to read.
@@ -323,11 +302,7 @@ public:
    * @throw Glib::IOChannelError
    * @throw Glib::ConvertError
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus read(Glib::ustring& str, gsize count);
-#else
-  IOStatus read(Glib::ustring& str, gsize count, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
   /** Read a whole line.
    * Reads until the line separator is found, which is included
@@ -337,11 +312,7 @@ public:
    * @throw Glib::IOChannelError
    * @throw Glib::ConvertError
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus read_line(Glib::ustring& line);
-#else
-  IOStatus read_line(Glib::ustring& line, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
   
 
   /** Reads all the remaining data from the file.
@@ -351,11 +322,7 @@ public:
    * @throw Glib::IOChannelError
    * @throw Glib::ConvertError
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus read_to_end(Glib::ustring& str);
-#else
-  IOStatus read_to_end(Glib::ustring& str, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
   
 
   /** Write a string to the I/O channel.
@@ -367,11 +334,7 @@ public:
    * @throw Glib::IOChannelError
    * @throw Glib::ConvertError
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus write(const Glib::ustring& str);
-#else
-  IOStatus write(const Glib::ustring& str, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
   /** Write a memory area of @a count bytes to the I/O channel.
    * @param buf The start of the memory area.
@@ -400,12 +363,7 @@ public:
    * or G::IOChannelError.
    * @return The status of the operation.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus write(const char* buf, gssize count, gsize& bytes_written);
-#else
-  IOStatus write(const char* buf, gssize count, gsize& bytes_written, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Write a single UCS-4 character to the I/O channel.
    * @param unichar The character to write.
@@ -420,12 +378,7 @@ public:
    * or G::IOChannelError.
    * @return A G::IOStatus.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus write(gunichar unichar);
-#else
-  IOStatus write(gunichar unichar, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Seek the I/O channel to a specific position.
    * @param offset The offset in bytes from the position specified by @a type.
@@ -446,12 +399,7 @@ public:
    * @param error A location to return an error of type G::IOChannelError.
    * @return The status of the operation.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus seek(gint64 offset, SeekType type = SEEK_TYPE_SET);
-#else
-  IOStatus seek(gint64 offset, SeekType type, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Flush the buffers of the I/O channel.
    * @return The status of the operation.
@@ -465,12 +413,7 @@ public:
    * G::IO_CHANNEL_NORMAL, G::IO_CHANNEL_AGAIN, or
    * G::IO_CHANNEL_ERROR.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus flush();
-#else
-  IOStatus flush(std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Close the I/O channel.
    * Any pending data to be written will be flushed if @a flush is <tt>true</tt>.
@@ -488,12 +431,7 @@ public:
    * @param err Location to store a G::IOChannelError.
    * @return The status of the operation.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus close(bool flush = true);
-#else
-  IOStatus close(bool flush, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Get the IOChannel internal buffer size.
    * @return The buffer size.
@@ -549,12 +487,7 @@ public:
    * @param error A location to return an error of type G::IOChannelError.
    * @return The status of the operation.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus set_flags(IOFlags flags);
-#else
-  IOStatus set_flags(IOFlags flags, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   /** Set the buffering status of the I/O channel.
    * The buffering state can only be set if the channel's encoding is
@@ -684,11 +617,7 @@ public:
    * @return Glib::IO_STATUS_NORMAL if the encoding was successfully set.
    * @throw Glib::IOChannelError
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   IOStatus set_encoding(const std::string& encoding = std::string());
-#else
-  IOStatus set_encoding(const std::string& encoding, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
   
 
   /** Get the encoding of the I/O channel.
diff --git a/libs/glibmm2/glibmm/main.cc b/libs/glibmm2/glibmm/main.cc
index cada0401c7..45e1e0d684 100644
--- a/libs/glibmm2/glibmm/main.cc
+++ b/libs/glibmm2/glibmm/main.cc
@@ -189,19 +189,15 @@ static gboolean glibmm_source_callback(void* data)
 {
   SourceConnectionNode *const conn_data = static_cast<SourceConnectionNode*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     // Recreate the specific slot from the generic slot node.
     return (*static_cast<sigc::slot<bool>*>(conn_data->get_slot()))();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
   return 0;
 }
 
@@ -210,43 +206,16 @@ static gboolean glibmm_iosource_callback(GIOChannel*, GIOCondition condition, vo
   SourceCallbackData *const callback_data = static_cast<SourceCallbackData*>(data);
   g_return_val_if_fail(callback_data->node != 0, 0);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     // Recreate the specific slot from the generic slot node.
-    return (*static_cast<sigc::slot<bool, Glib::IOCondition>*>(callback_data->node->get_slot()))
+    return (*static_cast<sigc::slot<bool,Glib::IOCondition>*>(callback_data->node->get_slot()))
                                   ((Glib::IOCondition) condition);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-  return 0;
-}
-
-/* Only used by SignalChildWatch::connect().
- * These don't use Glib::Source, to avoid the unnecessary overhead
- * of a completely unused wrapper object.
- */
-static gboolean glibmm_child_watch_callback(GPid pid, gint child_status, void* data)
-{
-  SourceConnectionNode *const conn_data = static_cast<SourceConnectionNode*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    //Recreate the specific slot from the generic slot node.
-    (*static_cast<sigc::slot<void, GPid, int>*>(conn_data->get_slot()))(pid, child_status);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
   return 0;
 }
 
@@ -395,40 +364,6 @@ SignalIO signal_io()
   return SignalIO(0); // 0 means default context
 }
 
-/**** Glib::SignalChildWatch **************************************************/
-
-inline
-SignalChildWatch::SignalChildWatch(GMainContext* context)
-:
-  context_ (context)
-{}
-
-sigc::connection SignalChildWatch::connect(const sigc::slot<void, GPid, int>& slot,
-                                        GPid pid, int priority)
-{
-  SourceConnectionNode *const conn_node = new SourceConnectionNode(slot);
-  const sigc::connection connection(*conn_node->get_slot());
-
-  GSource *const source = g_child_watch_source_new(pid);
- 
-  if(priority != G_PRIORITY_DEFAULT)
-    g_source_set_priority(source, priority);
-
-  g_source_set_callback(
-      source, (GSourceFunc)&glibmm_child_watch_callback, conn_node,
-      &SourceConnectionNode::destroy_notify_callback);
-
-  g_source_attach(source, context_);
-  g_source_unref(source); // GMainContext holds a reference
-
-  conn_node->install(source);
-  return connection;
-}
-
-SignalChildWatch signal_child_watch()
-{
-  return SignalChildWatch(0); // 0 means default context
-}
 
 /**** Glib::MainContext ****************************************************/
 
@@ -550,11 +485,6 @@ SignalIO MainContext::signal_io()
   return SignalIO(gobj());
 }
 
-SignalChildWatch MainContext::signal_child_watch()
-{
-  return SignalChildWatch(gobj());
-}
-
 void MainContext::reference() const
 {
   g_main_context_ref(reinterpret_cast<GMainContext*>(const_cast<MainContext*>(this)));
@@ -817,40 +747,30 @@ Source* Source::get_wrapper(GSource* source)
 // static
 gboolean Source::prepare_vfunc(GSource* source, int* timeout)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Source *const self = get_wrapper(source);
     return self->prepare(*timeout);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
   return 0;
 }
 
 // static
 gboolean Source::check_vfunc(GSource* source)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Source *const self = get_wrapper(source);
     return self->check();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
   return 0;
 }
 
@@ -862,19 +782,15 @@ gboolean Source::dispatch_vfunc(GSource*, GSourceFunc callback, void* user_data)
   g_return_val_if_fail(callback == &glibmm_dummy_source_callback, 0);
   g_return_val_if_fail(callback_data != 0 && callback_data->node != 0, 0);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Source *const self = callback_data->wrapper;
     return self->dispatch(callback_data->node->get_slot());
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
   return 0;
 }
 
diff --git a/libs/glibmm2/glibmm/main.h b/libs/glibmm2/glibmm/main.h
index 922a091d30..4165be3620 100644
--- a/libs/glibmm2/glibmm/main.h
+++ b/libs/glibmm2/glibmm/main.h
@@ -277,29 +277,6 @@ private:
   SignalIO& operator=(const SignalIO&);
 };
 
-class SignalChildWatch
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  explicit inline SignalChildWatch(GMainContext* context);
-#endif
-  /** Connects a child watch handler.
-   * @code
-   * Glib::signal_child_watch().connect(sigc::ptr_fun(&child_watch_handler), pid);
-   * @endcode
-   * @param slot A slot to call when child @a pid exited.
-   * @param pid The child to watch for.
-   * @param priority The priority of the new event source.
-   * @return A connection handle, which can be used to disconnect the handler.
-   */
-  sigc::connection connect(const sigc::slot<void,GPid, int>& slot, GPid pid, 
-int priority = PRIORITY_DEFAULT);
-private:
-  GMainContext* context_;
-
-  // no copy assignment
-  SignalChildWatch& operator=(const SignalChildWatch&);
-};
 
 /** Convenience timeout signal.
  * @return A signal proxy; you want to use SignalTimeout::connect().
@@ -316,11 +293,6 @@ SignalIdle signal_idle();
  */
 SignalIO signal_io();
 
-/** Convenience child watch signal.
- * @return A signal proxy; you want to use SignalChildWatch::connect().
- */
-SignalChildWatch signal_child_watch();
-
 
 /** Main context.
  */
@@ -341,10 +313,7 @@ public:
   static Glib::RefPtr<MainContext> get_default();
 
   /** Runs a single iteration for the given main loop. 
-   * This involves checking to see if any event sources are ready to be processed, then if no events sources are 
-   * ready and may_block is true, waiting for a source to become ready, then dispatching the highest priority events 
-   * sources that are ready. Note that even when may_block is true, it is still possible for iteration() to return 
-   * false, since the the wait may be interrupted for other reasons than an event source becoming ready.
+   * This involves checking to see if any event sources are ready to be processed, then if no events sources are ready and may_block is true, waiting for a source to become ready, then dispatching the highest priority events sources that are ready. Note that even when may_block is true, it is still possible for iteration() to return FALSE, since the the wait may be interrupted for other reasons than an event source becoming ready.
    * @param may_block Whether the call may block.
    * @return true if events were dispatched.
    */
@@ -360,26 +329,21 @@ public:
   void wakeup();
 
   /** Tries to become the owner of the specified context. 
-   * If some other context is the owner of the context, returns FALSE immediately. Ownership is properly recursive: 
-   * the owner can require ownership again and will release ownership when release() is called as many times as 
-   * acquire().
+   * If some other context is the owner of the context, returns FALSE immediately. Ownership is properly recursive: the owner can require ownership again and will release ownership when release() is called as many times as acquire().
    * You must be the owner of a context before you can call prepare(), query(), check(), dispatch().
    * @return true if the operation succeeded, and this thread is now the owner of context.
    */
   bool acquire();
 
 
-  /** Tries to become the owner of the specified context, as with acquire(). But if another thread is the owner, 
-   * atomically drop mutex and wait on cond until that owner releases ownership or until cond is signaled, then try 
-   * again (once) to become the owner.
+  /** Tries to become the owner of the specified context, as with acquire(). But if another thread is the owner, atomically drop mutex and wait on cond until that owner releases ownership or until cond is signaled, then try again (once) to become the owner.
    * @param cond A condition variable.
    * @param mutex A mutex, currently held.
    * @return true if the operation succeeded, and this thread is now the owner of context.
    */
   bool wait(Glib::Cond& cond, Glib::Mutex& mutex);
 
-  /** Releases ownership of a context previously acquired by this thread with acquire(). If the context was acquired 
-   * multiple times, the only release ownership when release() is called as many times as it was acquired.
+  /** Releases ownership of a context previously acquired by this thread with acquire(). If the context was acquired multiple times, the only release ownership when release() is called as many times as it was acquired.
    */
   void release();
 
@@ -452,11 +416,6 @@ public:
    */
   SignalIO signal_io();
 
-  /** child watch signal, attached to this MainContext.
-   * @return A signal proxy; you want to use SignalChildWatch::connect().
-   */
-  SignalChildWatch signal_child_watch();
-
   void reference()   const;
   void unreference() const;
 
diff --git a/libs/glibmm2/glibmm/markup.cc b/libs/glibmm2/glibmm/markup.cc
index b8f7125c09..b0690406f6 100644
--- a/libs/glibmm2/glibmm/markup.cc
+++ b/libs/glibmm2/glibmm/markup.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/markup.h>
 #include <glibmm/private/markup_p.h>
 
@@ -104,15 +103,11 @@ void ParserCallbacks::start_element(GMarkupParseContext* context,
                                     void*                user_data,
                                     GError**             error)
 {
-  if(!&error) error = error; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   ParseContext& cpp_context = *static_cast<ParseContext*>(user_data);
   g_return_if_fail(context == cpp_context.gobj());
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Parser::AttributeMap attributes;
 
     if(attribute_names && attribute_values)
@@ -127,7 +122,6 @@ void ParserCallbacks::start_element(GMarkupParseContext* context,
     }
 
     cpp_context.get_parser()->on_start_element(cpp_context, element_name, attributes);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(MarkupError& err)
   {
@@ -137,7 +131,6 @@ void ParserCallbacks::start_element(GMarkupParseContext* context,
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 void ParserCallbacks::end_element(GMarkupParseContext* context,
@@ -145,17 +138,12 @@ void ParserCallbacks::end_element(GMarkupParseContext* context,
                                   void*                user_data,
                                   GError**             error)
 {
-  if(!&error) error = error; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   ParseContext& cpp_context = *static_cast<ParseContext*>(user_data);
   g_return_if_fail(context == cpp_context.gobj());
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     cpp_context.get_parser()->on_end_element(cpp_context, element_name);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(MarkupError& err)
   {
@@ -165,7 +153,6 @@ void ParserCallbacks::end_element(GMarkupParseContext* context,
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 void ParserCallbacks::text(GMarkupParseContext* context,
@@ -174,17 +161,12 @@ void ParserCallbacks::text(GMarkupParseContext* context,
                            void*                user_data,
                            GError**             error)
 {
-  if(!&error) error = error; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   ParseContext& cpp_context = *static_cast<ParseContext*>(user_data);
   g_return_if_fail(context == cpp_context.gobj());
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     cpp_context.get_parser()->on_text(cpp_context, Glib::ustring(text, text + text_len));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(MarkupError& err)
   {
@@ -194,7 +176,6 @@ void ParserCallbacks::text(GMarkupParseContext* context,
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 void ParserCallbacks::passthrough(GMarkupParseContext* context,
@@ -203,18 +184,13 @@ void ParserCallbacks::passthrough(GMarkupParseContext* context,
                                   void*                user_data,
                                   GError**             error)
 {
-  if(!&error) error = error; //Avoid an unused parameter warning when GLIBMM_EXCEPTIONS_ENABLED is used.
-
   ParseContext& cpp_context = *static_cast<ParseContext*>(user_data);
   g_return_if_fail(context == cpp_context.gobj());
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     cpp_context.get_parser()->on_passthrough(
         cpp_context, Glib::ustring(passthrough_text, passthrough_text + text_len));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(MarkupError& err)
   {
@@ -224,7 +200,6 @@ void ParserCallbacks::passthrough(GMarkupParseContext* context,
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 void ParserCallbacks::error(GMarkupParseContext* context,
@@ -236,18 +211,14 @@ void ParserCallbacks::error(GMarkupParseContext* context,
   g_return_if_fail(context == cpp_context.gobj());
   g_return_if_fail(error->domain == G_MARKUP_ERROR);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     cpp_context.get_parser()->on_error(cpp_context, MarkupError(g_error_copy(error)));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 
@@ -371,17 +342,9 @@ Glib::MarkupError::Code Glib::MarkupError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::MarkupError::throw_func(GError* gobject)
 {
   throw Glib::MarkupError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::MarkupError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::MarkupError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
diff --git a/libs/glibmm2/glibmm/markup.h b/libs/glibmm2/glibmm/markup.h
index 99305078ea..83076f15b8 100644
--- a/libs/glibmm2/glibmm/markup.h
+++ b/libs/glibmm2/glibmm/markup.h
@@ -95,14 +95,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
diff --git a/libs/glibmm2/glibmm/miscutils.cc b/libs/glibmm2/glibmm/miscutils.cc
index 5deb832cba..b25318fca7 100644
--- a/libs/glibmm2/glibmm/miscutils.cc
+++ b/libs/glibmm2/glibmm/miscutils.cc
@@ -100,8 +100,7 @@ std::string get_real_name()
 
 std::string get_home_dir()
 {
-  const char *const value = g_get_home_dir();
-  return (value) ? std::string(value) : std::string();
+  return std::string(g_get_home_dir());
 }
 
 std::string get_tmp_dir()
@@ -145,25 +144,21 @@ std::string path_get_dirname(const std::string& filename)
 
 std::string build_filename(const Glib::ArrayHandle<std::string>& elements)
 {
-  return Glib::convert_return_gchar_ptr_to_stdstring( g_build_filenamev(const_cast<char**>(elements.data())) );
-
+  return build_path(G_DIR_SEPARATOR_S, elements);
 }
 
 std::string build_filename(const std::string& elem1, const std::string& elem2)
 {
   const char *const elements[] = { elem1.c_str(), elem2.c_str(), 0 };
-  return build_filename(elements);                                          
+  return build_path(G_DIR_SEPARATOR_S, elements);                                          
 }
 
-std::string build_path(const std::string& separator, const Glib::ArrayHandle<std::string>& elements)
-{
-  return Glib::convert_return_gchar_ptr_to_stdstring( g_build_pathv(separator.c_str(), const_cast<char**>(elements.data())) );
-
 /* Yes, this reimplements the functionality of g_build_path() -- because
  * it takes a varargs list, and calling it several times would result
  * in different behaviour.
  */
-  /*
+std::string build_path(const std::string& separator, const Glib::ArrayHandle<std::string>& elements)
+{
   std::string result;
   result.reserve(256); //TODO: Explain why this magic number is useful. murrayc
 
@@ -234,7 +229,6 @@ std::string build_path(const std::string& separator, const Glib::ArrayHandle<std
     result += last_trailing;
 
   return result;
-  */
 }
 
 std::string find_program_in_path(const std::string& program)
diff --git a/libs/glibmm2/glibmm/miscutils.h b/libs/glibmm2/glibmm/miscutils.h
index 651d1b2f3c..8087add39f 100644
--- a/libs/glibmm2/glibmm/miscutils.h
+++ b/libs/glibmm2/glibmm/miscutils.h
@@ -137,7 +137,7 @@ std::string get_user_name();
 std::string get_real_name();
 
 /** Gets the current user's home directory.
- * @return The current user's home directory or an empty string if not defined.
+ * @return The current user's home directory.
  */
 std::string get_home_dir();
 
diff --git a/libs/glibmm2/glibmm/module.cc b/libs/glibmm2/glibmm/module.cc
index 3f64118816..3bc621ff73 100644
--- a/libs/glibmm2/glibmm/module.cc
+++ b/libs/glibmm2/glibmm/module.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/module.h>
 #include <glibmm/private/module_p.h>
 
@@ -63,10 +62,9 @@ bool Module::get_supported()
   return g_module_supported();
 }
 
-
 void Module::make_resident()
 {
-g_module_make_resident(gobj()); 
+  g_module_make_resident(gobj());
 }
 
 std::string Module::get_last_error()
@@ -74,7 +72,6 @@ std::string Module::get_last_error()
   return Glib::convert_const_gchar_ptr_to_stdstring(g_module_error());
 }
 
-
 bool Module::get_symbol(const std::string& symbol_name, void*& symbol) const
 {
   return g_module_symbol(const_cast<GModule*>(gobj()), symbol_name.c_str(), &(symbol));
diff --git a/libs/glibmm2/glibmm/module.h b/libs/glibmm2/glibmm/module.h
index 8a45f7c54a..0c73bc9a81 100644
--- a/libs/glibmm2/glibmm/module.h
+++ b/libs/glibmm2/glibmm/module.h
@@ -53,8 +53,7 @@ namespace Glib
 enum ModuleFlags
 {
   MODULE_BIND_LAZY = 1 << 0,
-  MODULE_BIND_LOCAL = 1 << 1,
-  MODULE_BIND_MASK = 0x03
+  MODULE_BIND_MASK = 0x01
 };
 
 /** @ingroup glibmmEnums */
diff --git a/libs/glibmm2/glibmm/object.h b/libs/glibmm2/glibmm/object.h
index 60de61a820..3f196f9cc5 100644
--- a/libs/glibmm2/glibmm/object.h
+++ b/libs/glibmm2/glibmm/object.h
@@ -20,12 +20,6 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-//X11 defines DestroyNotify and some other non-prefixed stuff, and it's too late to change that now,
-//so let's give people a clue about the compilation errors that they will see:
-#ifdef DestroyNotify
-  #error "X11/Xlib.h seems to have been included before this header. Due to some commonly-named macros in X11/Xlib.h, it may only be included after any glibmm, gdkmm, or gtkmm headers."
-#endif //DestroyNotify
-
 #include <glibmm/objectbase.h>
 #include <glibmm/wrap.h>
 #include <glibmm/quark.h>
@@ -34,8 +28,6 @@
 #include <glibmm/containerhandle_shared.h> //Because its specializations may be here.
 #include <glibmm/value.h>
 
-#include <glibmmconfig.h>
-
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 extern "C"
 {
@@ -92,7 +84,7 @@ private:
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
-class GLIBMM_API Object : virtual public ObjectBase
+class Object : virtual public ObjectBase
 {
 public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -196,7 +188,7 @@ struct TypeTraits< Glib::RefPtr<T> >
   }
 };
 
-//This confuses the SUN Forte compiler, so we ifdef it out:
+//This confuse the SUN Forte compiler, so we ifdef it out:
 #ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
 
 /** Partial specialization for pointers to const GObject instances.
diff --git a/libs/glibmm2/glibmm/objectbase.cc b/libs/glibmm2/glibmm/objectbase.cc
index 8aaaf8daf1..1bb14e79fd 100644
--- a/libs/glibmm2/glibmm/objectbase.cc
+++ b/libs/glibmm2/glibmm/objectbase.cc
@@ -22,7 +22,6 @@
 
 #include <glibmm/quark.h>
 #include <glibmm/objectbase.h>
-#include <glibmm/propertyproxy_base.h> //For PropertyProxyConnectionNode
 
 
 namespace
@@ -32,7 +31,7 @@ namespace
 // char array rather than a string literal allows for fast pointer comparison,
 // which is otherwise not guaranteed to work.
 
-static const char anonymous_custom_type_name[] = "gtkmm__anonymous_custom_type";
+const char anonymous_custom_type_name[] = "gtkmm__anonymous_custom_type";
 
 } // anonymous namespace
 
@@ -256,23 +255,6 @@ void ObjectBase::get_property_value(const Glib::ustring& property_name, Glib::Va
   g_object_get_property(const_cast<GObject*>(gobj()), property_name.c_str(), value.gobj());
 }
 
-void ObjectBase::connect_property_changed(const Glib::ustring& property_name, const sigc::slot<void>& slot)
-{
-  // Create a proxy to hold our connection info
-  // This will be deleted by destroy_notify_handler.
-  PropertyProxyConnectionNode* pConnectionNode = new PropertyProxyConnectionNode(slot, gobj());
-
-  // connect it to gtk+
-  // pConnectionNode will be passed as the data argument to the callback.
-  // The callback will then call the virtual Object::property_change_notify() method,
-  // which will contain a switch/case statement which will examine the property name.
-  const Glib::ustring notify_signal_name = "notify::" + property_name;
-  pConnectionNode->connection_id_ = g_signal_connect_data(gobj(),
-         notify_signal_name.c_str(), (GCallback)(&PropertyProxyConnectionNode::callback), pConnectionNode, 
-         &PropertyProxyConnectionNode::destroy_notify_handler,
-         G_CONNECT_AFTER);
-}
-
 
 bool _gobject_cppinstance_already_deleted(GObject* gobject)
 {
diff --git a/libs/glibmm2/glibmm/objectbase.h b/libs/glibmm2/glibmm/objectbase.h
index 2ad6e65030..bddfdcf6ca 100644
--- a/libs/glibmm2/glibmm/objectbase.h
+++ b/libs/glibmm2/glibmm/objectbase.h
@@ -23,15 +23,11 @@
 
 #include <glibmm/signalproxy.h>
 #include <glibmm/propertyproxy.h>
-#include <glibmm/ustring.h>
-#include <glibmm/value.h>
 #include <sigc++/trackable.h>
 #include <typeinfo>
 #include <glibmmconfig.h>
 #include <glibmm/debug.h>
 
-#include <glibmmconfig.h>
-
 GLIBMM_USING_STD(type_info)
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -48,44 +44,35 @@ class GSigConnectionNode;
 
 //This inherits virtually from sigc::trackable so that people can multiply inherit glibmm classes from other sigc::trackable-derived classes.
 //See bugzilla.gnome.org bug # 116280
-/** Glib::ObjectBase is a common base class for Objects and Interfaces.
- *
- * This is used as virtual base class.  This means the ObjectBase
- * constructor runs before all others, either implicitly or explicitly.  Each of
- * the available constructors initializes custom_type_name_ in a different way.
- */
-class GLIBMM_API ObjectBase : virtual public sigc::trackable
+class ObjectBase : virtual public sigc::trackable
 {
 protected:
-  /** This default constructor is called implicitly from the constructor of user-derived
-   * classes, even if, for instance, Gtk::Button calls a different ObjectBase constructor.
-   * This is normal behaviour for C++ virtual inheritance.
-   * 
-   * The GType name will be gtkmm__anonymous_custom_type.
-   */
-  ObjectBase();
+  // Glib::ObjectBase is used as virtual base class.  This means the ObjectBase
+  // ctor runs before all others -- either implicitly or explicitly.  Each of
+  // the available ctors initializes custom_type_name_ in a different way:
+  //
+  // 1) default:      custom_type_name_ = "gtkmm__anonymous_custom_type"
+  // 2) const char*:  custom_type_name_ = custom_type_name
+  // 3) type_info:    custom_type_name_ = custom_type_info.name()
+  //
+  // All classes generated by gtkmmproc use ctor 2) with custom_type_name = 0,
+  // which essentially means it's not a custom type.  This is used to optimize
+  // vfunc and signal handler callbacks -- since the C++ virtual methods are
+  // not overridden, invocation can be skipped.
+  //
+  // The default ctor 1) is called implicitly from the ctor of user-derived
+  // classes -- yes, even if e.g. Gtk::Button calls ctor 2), a derived ctor
+  // always overrides this choice.  The language itself ensures that the ctor
+  // is only invoked once.
+  //
+  // Ctor 3) is a special feature to allow creation of derived types on the
+  // fly, without having to use g_object_new() manually.  This feature is
+  // sometimes necessary, e.g. to implement a custom Gtk::CellRenderer.  The
+  // neat trick with the virtual base class ctor makes it possible to reuse
+  // the same direct base class' ctor as with non-custom types.
 
-  /** A derived constructor always overrides this choice.
-   * The C++ language itself ensures that the constructor
-   * is only invoked once.
-   * 
-   * All classes generated by gtkmmproc use this constructor, with custom_type_name = 0,
-   * which essentially means it's not a custom type.  This is used to optimize
-   * vfunc and signal handler callbacks -- since the C++ virtual methods are
-   * not overridden, invocation can be skipped.
-   *
-   * The GType name will be @a custom_type_name.
-   */
+  ObjectBase();
   explicit ObjectBase(const char* custom_type_name);
-
-  /** This constructor is a special feature to allow creation of derived types on the
-   * fly, without having to use g_object_new() manually.  This feature is
-   * sometimes necessary, e.g. to implement a custom Gtk::CellRenderer.  The
-   * neat trick with the virtual base class ctor makes it possible to reuse
-   * the same direct base class' constructor as with non-custom types.
-   *
-   * The GType name will be @a custom_type_info.name().
-   */
   explicit ObjectBase(const std::type_info& custom_type_info);
 
   virtual ~ObjectBase() = 0;
@@ -109,38 +96,22 @@ public:
   template <class PropertyType>
   void get_property(const Glib::ustring& property_name, PropertyType& value) const;
 
-  /** You can use the signal_changed() signal of the property proxy instead, 
-   * but this is necessary when using the reduced API.
-   */
-  void connect_property_changed(const Glib::ustring& property_name, const sigc::slot<void>& slot);
-
-  /** Increment the reference count for this object.
-   * You should never need to do this manually - use the object via a RefPtr instead.
-   */
-  virtual void reference() const;
-
-  /** Decrement the reference count for this object.
-   * You should never need to do this manually - use the object via a RefPtr instead.
-   */
+  
+  virtual void reference()   const;
   virtual void unreference() const;
 
-  ///Provides access to the underlying C GtkObject.
   inline GObject*       gobj()       { return gobject_; }
-
-  ///Provides access to the underlying C GtkObject.
   inline const GObject* gobj() const { return gobject_; }
 
-  /// Give a ref-ed copy to someone. Use for direct struct access.
+  // Give a ref-ed copy to someone. Use for direct struct access.
   GObject* gobj_copy() const;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   static ObjectBase* _get_current_wrapper(GObject* object);
   bool _cpp_destruction_is_in_progress() const;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif
 
 protected:
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
   GObject*            gobject_; // the GLib/GDK/GTK+ object instance
   const char*         custom_type_name_;
   bool                cpp_destruction_in_progress_;
@@ -152,16 +123,13 @@ protected:
   virtual void destroy_notify_();
 
   void _set_current_wrapper(GObject* object);
-#endif //DOXYGEN_SHOULD_SKIP_THIS
 
 private:
   // noncopyable
   ObjectBase(const ObjectBase&);
   ObjectBase& operator=(const ObjectBase&);
 
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
   virtual void set_manage(); // calls g_error()
-#endif //DOXYGEN_SHOULD_SKIP_THIS
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   friend class Glib::GSigConnectionNode; // for GSigConnectionNode::notify()
@@ -170,7 +138,7 @@ private:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
-template <class PropertyType> inline
+template <class PropertyType>
 void ObjectBase::set_property(const Glib::ustring& property_name, const PropertyType& value)
 {
   Glib::Value<PropertyType> property_value;
@@ -180,7 +148,7 @@ void ObjectBase::set_property(const Glib::ustring& property_name, const Property
   this->set_property_value(property_name, property_value);
 }
 
-template <class PropertyType> inline
+template <class PropertyType>
 void ObjectBase::get_property(const Glib::ustring& property_name, PropertyType& value) const
 {
   Glib::Value<PropertyType> property_value;
diff --git a/libs/glibmm2/glibmm/optioncontext.cc b/libs/glibmm2/glibmm/optioncontext.cc
index 8d7c35f2a8..5a96ad414d 100644
--- a/libs/glibmm2/glibmm/optioncontext.cc
+++ b/libs/glibmm2/glibmm/optioncontext.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/optioncontext.h>
 #include <glibmm/private/optioncontext_p.h>
 
@@ -98,18 +97,10 @@ Glib::OptionError::Code Glib::OptionError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::OptionError::throw_func(GError* gobject)
 {
   throw Glib::OptionError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::OptionError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::OptionError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
 namespace Glib
@@ -118,7 +109,7 @@ namespace Glib
 
 void OptionContext::set_help_enabled(bool help_enabled)
 {
-g_option_context_set_help_enabled(gobj(), static_cast<int>(help_enabled)); 
+  g_option_context_set_help_enabled(gobj(), static_cast<int>(help_enabled));
 }
 
 bool OptionContext::get_help_enabled() const
@@ -128,7 +119,7 @@ bool OptionContext::get_help_enabled() const
 
 void OptionContext::set_ignore_unknown_options(bool ignore_unknown)
 {
-g_option_context_set_ignore_unknown_options(gobj(), static_cast<int>(ignore_unknown)); 
+  g_option_context_set_ignore_unknown_options(gobj(), static_cast<int>(ignore_unknown));
 }
 
 bool OptionContext::get_ignore_unknown_options() const
@@ -136,24 +127,12 @@ bool OptionContext::get_ignore_unknown_options() const
   return g_option_context_get_ignore_unknown_options(const_cast<GOptionContext*>(gobj()));
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 bool OptionContext::parse(int& argc, char**& argv)
-#else
-bool OptionContext::parse(int& argc, char**& argv, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = g_option_context_parse(gobj(), &argc, &(argv), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  bool retvalue = g_option_context_parse(gobj(), &argc, &(argv), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
 
diff --git a/libs/glibmm2/glibmm/optioncontext.h b/libs/glibmm2/glibmm/optioncontext.h
index f37ed5049d..e621648935 100644
--- a/libs/glibmm2/glibmm/optioncontext.h
+++ b/libs/glibmm2/glibmm/optioncontext.h
@@ -54,14 +54,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
@@ -98,7 +91,7 @@ public:
    * and &lt;option&gt;--help-&lt;/option&gt;&lt;replaceable&gt;groupname&lt;/replaceable&gt; and creates
    * suitable output to stdout. 
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param help_enabled <tt>true</tt> to enable &lt;option&gt;--help&lt;/option&gt;, <tt>false</tt> to disable it.
    */
   void set_help_enabled(bool help_enabled = true);
@@ -107,7 +100,7 @@ public:
    * is turned on for @a context . See g_option_context_set_help_enabled().
    * @return <tt>true</tt> if automatic help generation is turned on.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_help_enabled() const;
   
@@ -119,7 +112,7 @@ public:
    * which don't start with a dash). But note that GOption cannot reliably
    * determine whether a non-option belongs to a preceding unknown option.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param ignore_unknown <tt>true</tt> to ignore unknown options, <tt>false</tt> to produce
    * an error when unknown options are met.
    */
@@ -129,7 +122,7 @@ public:
    * g_option_context_set_ignore_unknown_options().
    * @return <tt>true</tt> if unknown options are ignored.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_ignore_unknown_options() const;
 
@@ -141,10 +134,8 @@ public:
    * 
    * If the parsing is successful, any parsed arguments are
    * removed from the array and @a argc  and @a argv  are updated 
-   * accordingly. A '--' option is stripped from @a argv 
-   * unless there are unparsed options before and after it, 
-   * or some of the options after it start with '-'. In case 
-   * of an error, @a argc  and @a argv  are left unmodified. 
+   * accordingly. In case of an error, @a argc  and @a argv  are
+   * left unmodified.
    * 
    * If automatic &lt;option&gt;--help&lt;/option&gt; support is enabled
    * (see g_option_context_set_help_enabled()), and the 
@@ -157,14 +148,9 @@ public:
    * @return <tt>true</tt> if the parsing was successful, 
    * <tt>false</tt> if an error occurred
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   bool parse(int& argc, char**& argv);
-#else
-  bool parse(int& argc, char**& argv, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
   //g_option_context_add_main_entries(), just creates a group internally, adds them to it, and does a set_main_group()
   //- a group without callbacks seems to do some simple default parsing.
diff --git a/libs/glibmm2/glibmm/optionentry.cc b/libs/glibmm2/glibmm/optionentry.cc
index 691166a95b..7fd5c53c49 100644
--- a/libs/glibmm2/glibmm/optionentry.cc
+++ b/libs/glibmm2/glibmm/optionentry.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/optionentry.h>
 #include <glibmm/private/optionentry_p.h>
 
@@ -32,6 +31,7 @@ namespace Glib
 {
 
 OptionEntry::OptionEntry()
+: gobject_( new GOptionEntry() )
 {
   gobject_ = g_new0(GOptionEntry, 1);
 }
@@ -47,7 +47,7 @@ OptionEntry::~OptionEntry()
 OptionEntry::OptionEntry(const OptionEntry& src)
 {
   gobject_ = g_new0(GOptionEntry, 1);
-
+  
   operator=(src);
 }
 
@@ -57,29 +57,29 @@ OptionEntry& OptionEntry::operator=(const OptionEntry& src)
   {
     if(gobject_->long_name)
       g_free(const_cast<char*>(gobject_->long_name));
-
+      
     gobject_->long_name = g_strdup(src.gobject_->long_name);
 
     gobject_->short_name = src.gobject_->short_name; //It's just one char.
-
+    
     gobject_->flags = src.gobject_->flags;
     gobject_->arg = src.gobject_->arg;
     gobject_->arg_data = src.gobject_->arg_data; //Shared, because it's not owned by any instance of this class anyway.
-
+    
     if(gobject_->description)
       g_free(const_cast<char*>(gobject_->description));    
-
+    
     gobject_->description = g_strdup(src.gobject_->description);
-
+    
     if(gobject_->arg_description)
       g_free(const_cast<char*>(gobject_->arg_description));
-
+        
     gobject_->arg_description = g_strdup(src.gobject_->arg_description);
   }
-
+  
   return *this;
 }
-
+   
 
 } // namespace Glib
 
@@ -93,56 +93,56 @@ namespace Glib
 {
 
 
- Glib::ustring OptionEntry::get_long_name() const
+Glib::ustring OptionEntry::get_long_name() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->long_name);
 }
- 
- void OptionEntry::set_long_name(const Glib::ustring& value)
+
+void OptionEntry::set_long_name(const Glib::ustring& value)
 {
   gobj()->long_name = g_strdup((value).c_str());
 }
- 
- gchar OptionEntry::get_short_name() const
+
+gchar OptionEntry::get_short_name() const
 {
   return gobj()->short_name;
 }
- 
- void OptionEntry::set_short_name(const gchar& value)
+
+void OptionEntry::set_short_name(const gchar& value)
 {
   gobj()->short_name = value;
 }
- 
- int OptionEntry::get_flags() const
+
+int OptionEntry::get_flags() const
 {
   return gobj()->flags;
 }
- 
- void OptionEntry::set_flags(const int& value)
+
+void OptionEntry::set_flags(const int& value)
 {
   gobj()->flags = value;
 }
- 
- Glib::ustring OptionEntry::get_description() const
+
+Glib::ustring OptionEntry::get_description() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->description);
 }
- 
- void OptionEntry::set_description(const Glib::ustring& value)
+
+void OptionEntry::set_description(const Glib::ustring& value)
 {
   gobj()->description = g_strdup((value).c_str());
 }
- 
- Glib::ustring OptionEntry::get_arg_description() const
+
+Glib::ustring OptionEntry::get_arg_description() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->arg_description);
 }
- 
- void OptionEntry::set_arg_description(const Glib::ustring& value)
+
+void OptionEntry::set_arg_description(const Glib::ustring& value)
 {
   gobj()->arg_description = g_strdup((value).c_str());
 }
- 
+
 
 } // namespace Glib
 
diff --git a/libs/glibmm2/glibmm/optionentry.h b/libs/glibmm2/glibmm/optionentry.h
index 03751e95c4..f7ce6a4a1f 100644
--- a/libs/glibmm2/glibmm/optionentry.h
+++ b/libs/glibmm2/glibmm/optionentry.h
@@ -64,11 +64,7 @@ public:
   {
     FLAG_HIDDEN = 1 << 0,
     FLAG_IN_MAIN = 1 << 1,
-    FLAG_REVERSE = 1 << 2,
-    FLAG_NO_ARG = 1 << 3,
-    FLAG_FILENAME = 1 << 4,
-    FLAG_OPTIONAL_ARG = 1 << 5,
-    FLAG_NOALIAS = 1 << 6
+    FLAG_REVERSE = 1 << 2
   } GOptionFlags;
 
   OptionEntry();
@@ -78,23 +74,23 @@ public:
   OptionEntry& operator=(const OptionEntry& src);
 
  
-   Glib::ustring get_long_name() const;
-    void set_long_name(const Glib::ustring& value);
-   
-   gchar get_short_name() const;
-    void set_short_name(const gchar& value);
-   
-   int get_flags() const;
-    void set_flags(const int& value);
-   
+  Glib::ustring get_long_name() const;
+  void set_long_name(const Glib::ustring& value);
+  
+  gchar get_short_name() const;
+  void set_short_name(const gchar& value);
+  
+  int get_flags() const;
+  void set_flags(const int& value);
+  
   //TODO: G_OPTION_ARG_CALLBACK,
     
-   Glib::ustring get_description() const;
-    void set_description(const Glib::ustring& value);
-   
-   Glib::ustring get_arg_description() const;
-    void set_arg_description(const Glib::ustring& value);
-   
+  Glib::ustring get_description() const;
+  void set_description(const Glib::ustring& value);
+  
+  Glib::ustring get_arg_description() const;
+  void set_arg_description(const Glib::ustring& value);
+  
   GOptionEntry*       gobj()       { return gobject_; }
   const GOptionEntry* gobj() const { return gobject_; }
   
diff --git a/libs/glibmm2/glibmm/optiongroup.cc b/libs/glibmm2/glibmm/optiongroup.cc
index 6710a5f100..f8f35d2f29 100644
--- a/libs/glibmm2/glibmm/optiongroup.cc
+++ b/libs/glibmm2/glibmm/optiongroup.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/optiongroup.h>
 #include <glibmm/private/optiongroup_p.h>
 
@@ -167,20 +166,17 @@ void OptionGroup::add_entry_with_wrapper(const OptionEntry& entry, GOptionArg ar
     CppOptionEntry cppEntry;
     cppEntry.carg_type_ = arg_type;
     cppEntry.allocate_c_arg();
-
+    
     cppEntry.cpparg_ = cpp_arg;
-
+    
+    //Remember the C++/C mapping so that we can use it later:
+    map_entries_[name] = cppEntry;
+  
     //Give the information to the C API:
-
-    cppEntry.entry_ = new OptionEntry(entry); //g_option_group_add_entry() does not take its own copy, so we must keep the instance alive. */
-    //cppEntry.entry_ is deleted in release_c_arg(), via the destructor.
-
+    cppEntry.entry_ = new OptionEntry(entry); //g_option_group_add_entry() does not take its own copy, so we must keep the instance alive.*/
     cppEntry.entry_->gobj()->arg = arg_type;
     cppEntry.entry_->gobj()->arg_data = cppEntry.carg_;
- 
-    //Remember the C++/C mapping so that we can use it later:
-    map_entries_[name] = cppEntry;
-
+    
     add_entry(*(cppEntry.entry_));
   }
 }
@@ -448,7 +444,7 @@ namespace Glib
 
 void OptionGroup::set_translation_domain(const Glib::ustring& domain)
 {
-g_option_group_set_translation_domain(gobj(), domain.c_str()); 
+  g_option_group_set_translation_domain(gobj(), domain.c_str());
 }
 
 
diff --git a/libs/glibmm2/glibmm/optiongroup.h b/libs/glibmm2/glibmm/optiongroup.h
index b8d4e9c7a5..3d8ce78779 100644
--- a/libs/glibmm2/glibmm/optiongroup.h
+++ b/libs/glibmm2/glibmm/optiongroup.h
@@ -96,7 +96,7 @@ void          g_option_group_set_translate_func     (GOptionGroup       *group,
   /** A convenience function to use gettext() for translating
    * user-visible strings. 
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param domain The domain to use.
    */
   void set_translation_domain(const Glib::ustring& domain);
diff --git a/libs/glibmm2/glibmm/private/convert_p.h b/libs/glibmm2/glibmm/private/convert_p.h
index 743540ad3f..b8819e5c70 100644
--- a/libs/glibmm2/glibmm/private/convert_p.h
+++ b/libs/glibmm2/glibmm/private/convert_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_CONVERT_P_H
 #define _GLIBMM_CONVERT_P_H
-
-
 #endif /* _GLIBMM_CONVERT_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/date_p.h b/libs/glibmm2/glibmm/private/date_p.h
index 71b1fdde1e..8c09c9b7f5 100644
--- a/libs/glibmm2/glibmm/private/date_p.h
+++ b/libs/glibmm2/glibmm/private/date_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_DATE_P_H
 #define _GLIBMM_DATE_P_H
-
-
 #endif /* _GLIBMM_DATE_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/fileutils_p.h b/libs/glibmm2/glibmm/private/fileutils_p.h
index 27639284fa..2d15adfee7 100644
--- a/libs/glibmm2/glibmm/private/fileutils_p.h
+++ b/libs/glibmm2/glibmm/private/fileutils_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_FILEUTILS_P_H
 #define _GLIBMM_FILEUTILS_P_H
-
-
 #endif /* _GLIBMM_FILEUTILS_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/iochannel_p.h b/libs/glibmm2/glibmm/private/iochannel_p.h
index c462983d3d..a66f0a8483 100644
--- a/libs/glibmm2/glibmm/private/iochannel_p.h
+++ b/libs/glibmm2/glibmm/private/iochannel_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_IOCHANNEL_P_H
 #define _GLIBMM_IOCHANNEL_P_H
-
-
 #endif /* _GLIBMM_IOCHANNEL_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/markup_p.h b/libs/glibmm2/glibmm/private/markup_p.h
index 807833d0a2..2abb186965 100644
--- a/libs/glibmm2/glibmm/private/markup_p.h
+++ b/libs/glibmm2/glibmm/private/markup_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_MARKUP_P_H
 #define _GLIBMM_MARKUP_P_H
-
-
 #endif /* _GLIBMM_MARKUP_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/module_p.h b/libs/glibmm2/glibmm/private/module_p.h
index b65105b354..f06c0782f6 100644
--- a/libs/glibmm2/glibmm/private/module_p.h
+++ b/libs/glibmm2/glibmm/private/module_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_MODULE_P_H
 #define _GLIBMM_MODULE_P_H
-
-
 #endif /* _GLIBMM_MODULE_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/optioncontext_p.h b/libs/glibmm2/glibmm/private/optioncontext_p.h
index 549b34970e..a0499f001f 100644
--- a/libs/glibmm2/glibmm/private/optioncontext_p.h
+++ b/libs/glibmm2/glibmm/private/optioncontext_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_OPTIONCONTEXT_P_H
 #define _GLIBMM_OPTIONCONTEXT_P_H
-
-
 #endif /* _GLIBMM_OPTIONCONTEXT_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/optionentry_p.h b/libs/glibmm2/glibmm/private/optionentry_p.h
index f6f518f17b..df59695279 100644
--- a/libs/glibmm2/glibmm/private/optionentry_p.h
+++ b/libs/glibmm2/glibmm/private/optionentry_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_OPTIONENTRY_P_H
 #define _GLIBMM_OPTIONENTRY_P_H
-
-
 #endif /* _GLIBMM_OPTIONENTRY_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/optiongroup_p.h b/libs/glibmm2/glibmm/private/optiongroup_p.h
index fdd0cd9611..7bbc139ea4 100644
--- a/libs/glibmm2/glibmm/private/optiongroup_p.h
+++ b/libs/glibmm2/glibmm/private/optiongroup_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_OPTIONGROUP_P_H
 #define _GLIBMM_OPTIONGROUP_P_H
-
-
 #endif /* _GLIBMM_OPTIONGROUP_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/shell_p.h b/libs/glibmm2/glibmm/private/shell_p.h
index e0b5b55f9a..6d9c6258a8 100644
--- a/libs/glibmm2/glibmm/private/shell_p.h
+++ b/libs/glibmm2/glibmm/private/shell_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_SHELL_P_H
 #define _GLIBMM_SHELL_P_H
-
-
 #endif /* _GLIBMM_SHELL_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/spawn_p.h b/libs/glibmm2/glibmm/private/spawn_p.h
index 262bdc7ed4..fddcf2bf86 100644
--- a/libs/glibmm2/glibmm/private/spawn_p.h
+++ b/libs/glibmm2/glibmm/private/spawn_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_SPAWN_P_H
 #define _GLIBMM_SPAWN_P_H
-
-
 #endif /* _GLIBMM_SPAWN_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/thread_p.h b/libs/glibmm2/glibmm/private/thread_p.h
index 0f4d3c63d6..8767041773 100644
--- a/libs/glibmm2/glibmm/private/thread_p.h
+++ b/libs/glibmm2/glibmm/private/thread_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_THREAD_P_H
 #define _GLIBMM_THREAD_P_H
-
-
 #endif /* _GLIBMM_THREAD_P_H */
 
diff --git a/libs/glibmm2/glibmm/private/unicode_p.h b/libs/glibmm2/glibmm/private/unicode_p.h
index 7f1cad22dc..6ee135feda 100644
--- a/libs/glibmm2/glibmm/private/unicode_p.h
+++ b/libs/glibmm2/glibmm/private/unicode_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GLIBMM_UNICODE_P_H
 #define _GLIBMM_UNICODE_P_H
-
-
 #endif /* _GLIBMM_UNICODE_P_H */
 
diff --git a/libs/glibmm2/glibmm/property.cc b/libs/glibmm2/glibmm/property.cc
index f8f52b2f02..e801e0c1bd 100644
--- a/libs/glibmm2/glibmm/property.cc
+++ b/libs/glibmm2/glibmm/property.cc
@@ -19,9 +19,6 @@
  */
 
 #include <glibmm/property.h>
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-
 #include <glibmm/object.h>
 #include <cstddef>
 
@@ -78,7 +75,7 @@ namespace
 //
 // We can reimplement this later if necessary.
 
-static unsigned int property_to_id(Glib::ObjectBase& object, Glib::PropertyBase& property)
+unsigned int property_to_id(Glib::ObjectBase& object, Glib::PropertyBase& property)
 {
   void *const base_ptr = dynamic_cast<void*>(&object);
   void *const prop_ptr = &property;
@@ -199,5 +196,3 @@ void PropertyBase::notify()
 
 } // namespace Glib
 
-#endif //GLIBMM_PROPERTIES_ENABLED
-
diff --git a/libs/glibmm2/glibmm/property.h b/libs/glibmm2/glibmm/property.h
index 2b524f9bd8..f25ef84d1f 100644
--- a/libs/glibmm2/glibmm/property.h
+++ b/libs/glibmm2/glibmm/property.h
@@ -21,11 +21,9 @@
  */
 
 #include <glibmm/propertyproxy.h>
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-
 #include <glibmm/value.h>
 
+
 namespace Glib
 {
 
@@ -168,7 +166,6 @@ Glib::PropertyProxy<T> Property<T>::get_proxy()
 
 } // namespace Glib
 
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 #endif /* _GLIBMM_PROPERTY_H */
 
diff --git a/libs/glibmm2/glibmm/propertyproxy.h b/libs/glibmm2/glibmm/propertyproxy.h
index 392f5c24e0..bfba551611 100644
--- a/libs/glibmm2/glibmm/propertyproxy.h
+++ b/libs/glibmm2/glibmm/propertyproxy.h
@@ -24,7 +24,6 @@
 
 #include <glibmm/propertyproxy_base.h>
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 
 namespace Glib
 {
@@ -87,7 +86,12 @@ public:
   /** Set the value of this property.
    * @param data The new value for the property.
    */
-  void set_value(const PropertyType& data);
+  void set_value(const PropertyType& data)
+    {
+      PropertyProxy_Base& base = *this;
+      // The downcast to PropertyProxy<T> is safe, and avoids code duplication.
+      static_cast<PropertyProxy<T>&>(base).set_value(data);
+    }
 
   /** Set the value of this property back to its default value
    */
@@ -114,7 +118,12 @@ public:
   /** Get the value of this property.
    * @result The current value of the property.
    */
-  PropertyType get_value() const;
+  PropertyType get_value() const
+    {
+      const PropertyProxy_Base& base = *this;
+      // The downcast to PropertyProxy<T> is safe, and avoids code duplication.
+      return static_cast<const PropertyProxy<T>&>(base).get_value();
+    }
 
   operator PropertyType() const
     { return this->get_value(); }
@@ -145,37 +154,10 @@ T PropertyProxy<T>::get_value() const
   return value.get();
 }
 
-//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(), 
-//to avoid code duplication.
-//But the AIX compiler does not like that hack.
-template <class T>
-void PropertyProxy_WriteOnly<T>::set_value(const T& data)
-{
-  Glib::Value<T> value;
-  value.init(Glib::Value<T>::value_type());
-
-  value.set(data);
-  set_property_(value);
-}
-
-//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(), 
-//to avoid code duplication.
-//But the AIX compiler does not like that hack.
-template <class T>
-T PropertyProxy_ReadOnly<T>::get_value() const
-{
-  Glib::Value<T> value;
-  value.init(Glib::Value<T>::value_type());
-
-  get_property_(value);
-  return value.get();
-}
-
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 } // namespace Glib
 
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 #endif /* _GLIBMM_PROPERTYPROXY_H */
 
diff --git a/libs/glibmm2/glibmm/propertyproxy_base.cc b/libs/glibmm2/glibmm/propertyproxy_base.cc
index 66bd763cfa..d10c8cd352 100644
--- a/libs/glibmm2/glibmm/propertyproxy_base.cc
+++ b/libs/glibmm2/glibmm/propertyproxy_base.cc
@@ -21,9 +21,6 @@
  */
 
 #include <glibmm/propertyproxy_base.h>
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-
 #include <glibmm/signalproxy_connectionnode.h>
 #include <glibmm/object.h>
 #include <glibmm/private/object_p.h>
@@ -31,18 +28,26 @@
 namespace Glib
 {
 
-PropertyProxyConnectionNode::PropertyProxyConnectionNode(const sigc::slot_base& slot, GObject* gobject)
-: SignalProxyConnectionNode(slot, gobject)
+/** PropertyProxyConnectionNode is a connection node for use with SignalProxyProperty.
+  * It's like ProxyConnectionNode, but it contains the property name too.
+  */
+class PropertyProxyConnectionNode : public SignalProxyConnectionNode
 {
-}
+public:
+  friend class SignalProxyProperty;
+
+  PropertyProxyConnectionNode(const sigc::slot_base& slot, GObject* gobject, const gchar* property_name);
 
-void PropertyProxyConnectionNode::callback(GObject*, GParamSpec* pspec, gpointer data) //static
+protected:
+  //This will be examined in the callback.
+  //Should be a static string literal.
+  const gchar* property_name_;
+};
+
+PropertyProxyConnectionNode::PropertyProxyConnectionNode(const sigc::slot_base& slot, GObject* gobject, const gchar* property_name)
+: SignalProxyConnectionNode(slot, gobject),
+  property_name_(property_name)
 {
-  if(pspec && data)
-  {
-    if(sigc::slot_base *const slot = SignalProxyBase::data_to_slot(data))
-      (*static_cast<sigc::slot<void>*>(slot))();
-  }
 }
 
 //SignalProxyProperty implementation:
@@ -59,23 +64,41 @@ SignalProxyProperty::~SignalProxyProperty()
 
 sigc::connection SignalProxyProperty::connect(const SlotType& sl)
 {
-  // Create a proxy to hold our connection info
-  // This will be deleted by destroy_notify_handler.
-  PropertyProxyConnectionNode* pConnectionNode = new PropertyProxyConnectionNode(sl, obj_->gobj());
+  // create a proxy to hold our connection info
+  PropertyProxyConnectionNode* pConnectionNode = new PropertyProxyConnectionNode(sl, obj_->gobj(), property_name_ );
 
   // connect it to gtk+
   // pConnectionNode will be passed as the data argument to the callback.
   // The callback will then call the virtual Object::property_change_notify() method,
   // which will contain a switch/case statement which will examine the property name.
-  const Glib::ustring notify_signal_name = "notify::" + Glib::ustring(property_name_);
   pConnectionNode->connection_id_ = g_signal_connect_data(obj_->gobj(),
-         notify_signal_name.c_str(), (GCallback)(&PropertyProxyConnectionNode::callback), pConnectionNode,
+         "notify", (GCallback)(&callback), pConnectionNode,
          &PropertyProxyConnectionNode::destroy_notify_handler,
          G_CONNECT_AFTER);
 
   return sigc::connection(pConnectionNode->slot_);
 }
 
+void SignalProxyProperty::callback(GObject*, GParamSpec* pspec, gpointer data) //static
+{
+  if(pspec && data)
+  {
+    //Get the name of the property that has changed:
+    const char* property_name_changed = pspec->name;
+
+    //Get the name of the property that we are waiting for:
+    PropertyProxyConnectionNode* conn = static_cast<PropertyProxyConnectionNode*>(data);
+    const char* property_name_monitored = conn->property_name_;
+
+    //If it's the correct property, then call the signal handler:
+    if(strcmp(property_name_changed, property_name_monitored) == 0)
+    {
+      if(sigc::slot_base *const slot = data_to_slot(data))
+        (*static_cast<sigc::slot<void>*>(slot))();
+    }
+  }
+}
+
 
 //PropertyProxy_Base implementation:
 
@@ -126,4 +149,3 @@ void PropertyProxy_Base::reset_property_()
 
 } // namespace Glib
 
-#endif //GLIBMM_PROPERTIES_ENABLED
diff --git a/libs/glibmm2/glibmm/propertyproxy_base.h b/libs/glibmm2/glibmm/propertyproxy_base.h
index c220fd6248..036291df39 100644
--- a/libs/glibmm2/glibmm/propertyproxy_base.h
+++ b/libs/glibmm2/glibmm/propertyproxy_base.h
@@ -22,16 +22,13 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <glibmmconfig.h>
-
 #include <glibmm/value.h>
 #include <glibmm/signalproxy.h>
 
+
 namespace Glib
 {
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-
 class ObjectBase;
 
 /// Use the connect() method, with sigc::ptr_fun() or sig::mem_fun() to connect signals to signal handlers.
@@ -47,6 +44,7 @@ public:
   sigc::connection connect(const SlotType& sl);
 
 protected:
+  static void callback(GObject* object, GParamSpec* pspec, gpointer data);
 
   const char* property_name_; //Should be a static string literal.
 
@@ -73,7 +71,6 @@ protected:
   void reset_property_();
 
   ObjectBase* obj_; //The C++ wrapper instance of which this PropertyProxy is a member.
-
   const char* property_name_; //Should be a static string literal.
 
 private:
@@ -81,31 +78,7 @@ private:
   PropertyProxy_Base& operator=(const PropertyProxy_Base&);
 };
 
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-class SignalProxyProperty;
-
-/** PropertyProxyConnectionNode is a connection node for use with SignalProxyProperty.
-  * It's like ProxyConnectionNode, but it contains the property name too.
-  * This is not public API.
-  */
-class PropertyProxyConnectionNode : public SignalProxyConnectionNode
-{
-public:
-  friend class SignalProxyProperty;
-
-  PropertyProxyConnectionNode(const sigc::slot_base& slot, GObject* gobject);
-
-  static void callback(GObject* object, GParamSpec* pspec, gpointer data);
-};
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
 } // namespace Glib
 
-
-
 #endif /* _GLIBMM_PROPERTYPROXY_BASE_H */
 
diff --git a/libs/glibmm2/glibmm/refptr.h b/libs/glibmm2/glibmm/refptr.h
index 98212569a6..d375f7a52b 100644
--- a/libs/glibmm2/glibmm/refptr.h
+++ b/libs/glibmm2/glibmm/refptr.h
@@ -140,16 +140,6 @@ public:
   template <class T_CastFrom>
   static inline RefPtr<T_CppObject> cast_static(const RefPtr<T_CastFrom>& src);
 
-  /** Cast to non-const.
-   *
-   * The RefPtr can't be cast with the usual notation so instead you can use
-   * @code
-   *   ptr_unconst = RefPtr<UnConstType>::cast_const(ptr_const);
-   * @endcode
-   */
-  template <class T_CastFrom>
-  static inline RefPtr<T_CppObject> cast_const(const RefPtr<T_CastFrom>& src);
-
 private:
   T_CppObject* pCppObject_;
 };
@@ -312,19 +302,6 @@ RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_static(const RefPtr<T_CastFrom>& s
   return RefPtr<T_CppObject>(pCppObject);
 }
 
-template <class T_CppObject>
-  template <class T_CastFrom>
-inline
-RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_const(const RefPtr<T_CastFrom>& src)
-{
-  T_CppObject *const pCppObject = const_cast<T_CppObject*>(src.operator->());
-
-  if(pCppObject)
-    pCppObject->reference();
-
-  return RefPtr<T_CppObject>(pCppObject);
-}
-
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 /** @relates Glib::RefPtr */
diff --git a/libs/glibmm2/glibmm/shell.cc b/libs/glibmm2/glibmm/shell.cc
index a2b7bba943..adb3473dde 100644
--- a/libs/glibmm2/glibmm/shell.cc
+++ b/libs/glibmm2/glibmm/shell.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/shell.h>
 #include <glibmm/private/shell_p.h>
 
@@ -86,17 +85,9 @@ Glib::ShellError::Code Glib::ShellError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::ShellError::throw_func(GError* gobject)
 {
   throw Glib::ShellError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::ShellError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::ShellError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
diff --git a/libs/glibmm2/glibmm/shell.h b/libs/glibmm2/glibmm/shell.h
index 604324a99a..55512f57b2 100644
--- a/libs/glibmm2/glibmm/shell.h
+++ b/libs/glibmm2/glibmm/shell.h
@@ -60,14 +60,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
diff --git a/libs/glibmm2/glibmm/signalproxy.cc b/libs/glibmm2/glibmm/signalproxy.cc
index 6b6ed64579..67f7a9290b 100644
--- a/libs/glibmm2/glibmm/signalproxy.cc
+++ b/libs/glibmm2/glibmm/signalproxy.cc
@@ -89,19 +89,15 @@ void SignalProxyNormal::slot0_void_callback(GObject* self, void* data)
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper(self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = data_to_slot(data))
         (*static_cast<sigc::slot<void>*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
diff --git a/libs/glibmm2/glibmm/spawn.cc b/libs/glibmm2/glibmm/spawn.cc
index 0846fe31a9..cbc204cd70 100644
--- a/libs/glibmm2/glibmm/spawn.cc
+++ b/libs/glibmm2/glibmm/spawn.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/spawn.h>
 #include <glibmm/private/spawn_p.h>
 
@@ -39,23 +38,19 @@ extern "C"
  * We don't need to worry about (un)referencing, since the
  * child process gets its own copy of the parent's memory anyway.
  */
-static void child_setup_callback(void* user_data)
+void child_setup_callback(void* user_data)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     (*reinterpret_cast<sigc::slot<void>*>(user_data))();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void copy_output_buf(std::string* dest, const char* buf)
+void copy_output_buf(std::string* dest, const char* buf)
 {
   if(dest)
   {
@@ -308,17 +303,9 @@ Glib::SpawnError::Code Glib::SpawnError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::SpawnError::throw_func(GError* gobject)
 {
   throw Glib::SpawnError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::SpawnError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::SpawnError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
diff --git a/libs/glibmm2/glibmm/spawn.h b/libs/glibmm2/glibmm/spawn.h
index 014c9cc10e..df7a43a594 100644
--- a/libs/glibmm2/glibmm/spawn.h
+++ b/libs/glibmm2/glibmm/spawn.h
@@ -130,14 +130,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
diff --git a/libs/glibmm2/glibmm/streamiochannel.cc b/libs/glibmm2/glibmm/streamiochannel.cc
index e535cecd89..985931dec8 100644
--- a/libs/glibmm2/glibmm/streamiochannel.cc
+++ b/libs/glibmm2/glibmm/streamiochannel.cc
@@ -69,13 +69,7 @@ IOStatus StreamIOChannel::read_vfunc(char* buf, gsize count, gsize& bytes_read)
     return IO_STATUS_EOF;
 
   if(stream_in_->fail())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     throw Glib::Error(G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, "Reading from stream failed");
-    #else
-    return IO_STATUS_ERROR;
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
 
   return IO_STATUS_NORMAL;
 }
@@ -90,13 +84,7 @@ IOStatus StreamIOChannel::write_vfunc(const char* buf, gsize count, gsize& bytes
   stream_out_->write(buf, count);
 
   if(stream_out_->fail())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     throw Glib::Error(G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, "Writing to stream failed");
-    #else
-      return IO_STATUS_ERROR;
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
 
   bytes_written = count; // all or nothing ;)
 
@@ -130,13 +118,7 @@ IOStatus StreamIOChannel::seek_vfunc(gint64 offset, SeekType type)
   }
 
   if(failed)
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     throw Glib::Error(G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, "Seeking into stream failed");
-    #else
-    return IO_STATUS_ERROR;
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
 
   return Glib::IO_STATUS_NORMAL;
 }
@@ -165,22 +147,12 @@ IOStatus StreamIOChannel::close_vfunc()
   }
   else
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     throw Glib::Error(G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED,
                       "Attempt to close non-file stream");
-    #else
-    return IO_STATUS_ERROR;
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   if(failed)
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     throw Glib::Error(G_IO_CHANNEL_ERROR, G_IO_CHANNEL_ERROR_FAILED, "Failed to close stream");
-    #else
-    return IO_STATUS_ERROR;
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
 
   return IO_STATUS_NORMAL;
 }
diff --git a/libs/glibmm2/glibmm/stringutils.cc b/libs/glibmm2/glibmm/stringutils.cc
index 7a46413845..7113c014b8 100644
--- a/libs/glibmm2/glibmm/stringutils.cc
+++ b/libs/glibmm2/glibmm/stringutils.cc
@@ -51,13 +51,7 @@ double Glib::Ascii::strtod(const std::string&      str,
                            std::string::size_type  start_index)
 {
   if(start_index > str.size())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     throw std::out_of_range("out of range (strtod): start_index > str.size()");
-    #else
-      return 0;
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
 
   const char *const bufptr = str.c_str();
   char* endptr = 0;
@@ -69,8 +63,6 @@ double Glib::Ascii::strtod(const std::string&      str,
   {
     g_return_val_if_fail(err_no == ERANGE, result);
 
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    //Interpret the result in the event of an error:
     if(result > 0.0)
       throw std::overflow_error("overflow (strtod): positive number too large");
 
@@ -78,9 +70,6 @@ double Glib::Ascii::strtod(const std::string&      str,
       throw std::overflow_error("overflow (strtod): negative number too large");
 
     throw std::underflow_error("underflow (strtod): number too small");
-    #else
-    return result;
-    #endif // GLIBMM_EXCEPTIONS_ENABLED
   }
 
   if(endptr)
diff --git a/libs/glibmm2/glibmm/thread.cc b/libs/glibmm2/glibmm/thread.cc
index b8489c6f9b..1910c6fa38 100644
--- a/libs/glibmm2/glibmm/thread.cc
+++ b/libs/glibmm2/glibmm/thread.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/thread.h>
 #include <glibmm/private/thread_p.h>
 
@@ -38,13 +37,10 @@ static void* call_thread_entry_slot(void* data)
 {
   sigc::slot_base *const slot = reinterpret_cast<sigc::slot_base*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     // Recreate the specific slot, and drop the reference obtained by create().
     (*static_cast<sigc::slot<void>*>(slot))();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(Glib::Thread::Exit&)
   {
@@ -55,7 +51,6 @@ static void* call_thread_entry_slot(void* data)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   delete slot;
   return 0;
@@ -396,17 +391,9 @@ Glib::ThreadError::Code Glib::ThreadError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Glib::ThreadError::throw_func(GError* gobject)
 {
   throw Glib::ThreadError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Glib::ThreadError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Glib::ThreadError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 
diff --git a/libs/glibmm2/glibmm/thread.h b/libs/glibmm2/glibmm/thread.h
index 91935dc0ed..a4fa61da0b 100644
--- a/libs/glibmm2/glibmm/thread.h
+++ b/libs/glibmm2/glibmm/thread.h
@@ -178,14 +178,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
diff --git a/libs/glibmm2/glibmm/threadpool.cc b/libs/glibmm2/glibmm/threadpool.cc
index 556eeb7267..db9b089c9a 100644
--- a/libs/glibmm2/glibmm/threadpool.cc
+++ b/libs/glibmm2/glibmm/threadpool.cc
@@ -100,17 +100,14 @@ namespace
 
 static void call_thread_entry_slot(void* data, void* user_data)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Glib::ThreadPool::SlotList *const slot_list =
         static_cast<Glib::ThreadPool::SlotList*>(user_data);
 
     sigc::slot<void> slot (slot_list->pop(static_cast<sigc::slot<void>*>(data)));
 
     slot();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(Glib::Thread::Exit&)
   {
@@ -121,7 +118,6 @@ static void call_thread_entry_slot(void* data, void* user_data)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 } // anonymous namespace
diff --git a/libs/glibmm2/glibmm/unicode.cc b/libs/glibmm2/glibmm/unicode.cc
index 794730bc9d..cb58371dff 100644
--- a/libs/glibmm2/glibmm/unicode.cc
+++ b/libs/glibmm2/glibmm/unicode.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <glibmm/unicode.h>
 #include <glibmm/private/unicode_p.h>
 
diff --git a/libs/glibmm2/glibmm/unicode.h b/libs/glibmm2/glibmm/unicode.h
index 1df371de71..fd2f68a798 100644
--- a/libs/glibmm2/glibmm/unicode.h
+++ b/libs/glibmm2/glibmm/unicode.h
@@ -193,7 +193,7 @@ inline AsciiType& operator^=(AsciiType& lhs, AsciiType rhs)
 enum NormalizeMode
 {
   NORMALIZE_DEFAULT,
-  NORMALIZE_NFD = NORMALIZE_DEFAULT,
+  NORMALIZE_NFD,
   NORMALIZE_DEFAULT_COMPOSE,
   NORMALIZE_NFC = NORMALIZE_DEFAULT_COMPOSE,
   NORMALIZE_ALL,
diff --git a/libs/glibmm2/glibmm/ustring.cc b/libs/glibmm2/glibmm/ustring.cc
index 36d709da2a..76e8d01438 100644
--- a/libs/glibmm2/glibmm/ustring.cc
+++ b/libs/glibmm2/glibmm/ustring.cc
@@ -140,7 +140,7 @@ ustring::size_type utf8_char_offset(const std::string& str, ustring::size_type o
 // Helper to implement ustring::find_first_of() and find_first_not_of().
 // Returns the UTF-8 character offset, or ustring::npos if not found.
 //
-static ustring::size_type utf8_find_first_of(const std::string& str, ustring::size_type offset,
+ustring::size_type utf8_find_first_of(const std::string& str, ustring::size_type offset,
                                       const char* utf8_match, long utf8_match_size,
                                       bool find_not_of)
 {
@@ -176,7 +176,7 @@ static ustring::size_type utf8_find_first_of(const std::string& str, ustring::si
 // Helper to implement ustring::find_last_of() and find_last_not_of().
 // Returns the UTF-8 character offset, or ustring::npos if not found.
 //
-static ustring::size_type utf8_find_last_of(const std::string& str, ustring::size_type offset,
+ustring::size_type utf8_find_last_of(const std::string& str, ustring::size_type offset,
                                      const char* utf8_match, long utf8_match_size,
                                      bool find_not_of)
 {
@@ -1193,25 +1193,13 @@ std::istream& operator>>(std::istream& is, Glib::ustring& utf8_string)
 {
   std::string locale_string;
   is >> locale_string;
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   utf8_string = Glib::locale_to_utf8(locale_string);
-  #else
-  std::auto_ptr<Glib::Error> error; //TODO: Check this? 
-  utf8_string = Glib::locale_to_utf8(locale_string, error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
   return is;
 }
 
 std::ostream& operator<<(std::ostream& os, const Glib::ustring& utf8_string)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   os << Glib::locale_from_utf8(utf8_string);
-  #else
-  std::auto_ptr<Glib::Error> error; //TODO: Check this? 
-  os << Glib::locale_from_utf8(utf8_string, error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
   return os;
 }
 
diff --git a/libs/glibmm2/glibmm/ustring.h b/libs/glibmm2/glibmm/ustring.h
index b656bde38c..86578b43bb 100644
--- a/libs/glibmm2/glibmm/ustring.h
+++ b/libs/glibmm2/glibmm/ustring.h
@@ -233,11 +233,11 @@ public:
 #endif /* GLIBMM_HAVE_SUN_REVERSE_ITERATOR */
 
 #ifdef GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS
-  static GLIBMM_API const size_type npos = std::string::npos;
+  static const size_type npos = std::string::npos;
 #else
   //The IRIX MipsPro compiler says "The indicated constant value is not known",
   //so we need to initalize the static member data elsewhere.
-  static GLIBMM_API const size_type npos;
+  static const size_type npos;
 #endif
 
   /*! Default constructor, which creates an empty string.
@@ -269,13 +269,13 @@ public:
   /*! Construct a ustring as a copy of a substring.
    * @param src %Source ustring.
    * @param i Index of first character to copy from.
-   * @param n Number of UTF-8 characters to copy (defaults to copying the remainder).
+   * @param n Number of characters to copy (defaults to copying the remainder).
    */
   ustring(const ustring& src, size_type i, size_type n=npos);
 
   /*! Construct a ustring as a partial copy of a C string.
    * @param src %Source C string encoded as UTF-8.
-   * @param n Number of UTF-8 characters to copy.
+   * @param n Number of characters to copy.
    */
   ustring(const char* src, size_type n);
 
@@ -570,7 +570,7 @@ public:
 //! @{
 
   /*! Returns a new UTF-8 string with all characters characters converted to
-   * their uppercase equivalent, while honoring the current locale.  The
+   * their lowercase equivalent, while honoring the current locale.  The
    * resulting string may change in the number of bytes as well as in the
    * number of characters.  For instance, the German sharp&nbsp;s
    * <tt>&quot;&szlig;&quot;</tt> will be replaced by two characters
diff --git a/libs/glibmm2/glibmm/value.cc b/libs/glibmm2/glibmm/value.cc
index 12ba6fc986..adb3e90252 100644
--- a/libs/glibmm2/glibmm/value.cc
+++ b/libs/glibmm2/glibmm/value.cc
@@ -39,14 +39,6 @@ void ValueBase::init(GType type)
   g_value_init(&gobject_, type);
 }
 
-void ValueBase::init(const GValue* value)
-{
-  g_value_init(&gobject_, G_VALUE_TYPE(value));
-
-  if(value)
-    g_value_copy(value, &gobject_);
-}
-
 ValueBase::ValueBase(const ValueBase& other)
 {
   GLIBMM_INITIALIZE_STRUCT(gobject_, GValue);
diff --git a/libs/glibmm2/glibmm/value.h b/libs/glibmm2/glibmm/value.h
index a891418c6a..94203a324c 100644
--- a/libs/glibmm2/glibmm/value.h
+++ b/libs/glibmm2/glibmm/value.h
@@ -69,21 +69,9 @@ public:
    *
    * init() is not implemented as constructor, to avoid the necessity
    * to implement a forward constructor in each derived class.
-   *
-   * @param type The type that the Value should hold.
    */
   void init(GType type);
 
-  /** Setup the GValue storing the type and value of the specified @a value.
-   * Note that init() should never be called twice.
-   *
-   * init() is not implemented as constructor, to avoid the necessity
-   * to implement a forward constructor in each derived class.
-   *
-   * @param value The existing GValue.
-   */
-  void init(const GValue* value);
-
   /** Reset contents to the default value of its type.
    */
   void reset();
diff --git a/libs/glibmm2/glibmm/value_basictypes.cc b/libs/glibmm2/glibmm/value_basictypes.cc
index 9a3275075d..4d76b89f3e 100644
--- a/libs/glibmm2/glibmm/value_basictypes.cc
+++ b/libs/glibmm2/glibmm/value_basictypes.cc
@@ -275,7 +275,7 @@ GParamSpec* Value<float>::create_param_spec(const Glib::ustring& name) const
 {
   return g_param_spec_float(
       name.c_str(), 0, 0,
-      -G_MAXFLOAT, G_MAXFLOAT, g_value_get_float(&gobject_),
+      G_MINFLOAT, G_MAXFLOAT, g_value_get_float(&gobject_),
       GParamFlags(G_PARAM_READABLE | G_PARAM_WRITABLE));
 }
 
@@ -302,7 +302,7 @@ GParamSpec* Value<double>::create_param_spec(const Glib::ustring& name) const
 {
   return g_param_spec_double(
       name.c_str(), 0, 0,
-      -G_MAXDOUBLE, G_MAXDOUBLE, g_value_get_double(&gobject_),
+      G_MINDOUBLE, G_MAXDOUBLE, g_value_get_double(&gobject_),
       GParamFlags(G_PARAM_READABLE | G_PARAM_WRITABLE));
 }
 
diff --git a/libs/glibmm2/glibmm/value_custom.cc b/libs/glibmm2/glibmm/value_custom.cc
index 04a7c0dfaf..f277477712 100644
--- a/libs/glibmm2/glibmm/value_custom.cc
+++ b/libs/glibmm2/glibmm/value_custom.cc
@@ -26,7 +26,7 @@
 namespace
 {
 
-static void warn_already_registered(const char* location, const std::string& full_name)
+void warn_already_registered(const char* location, const std::string& full_name)
 {
   g_warning("file %s: (%s): The type name `%s' has been registered already.\n"
             "This is not supposed to happen -- please send a mail with detailed "
diff --git a/libs/glibmm2/glibmmconfig.h.in b/libs/glibmm2/glibmmconfig.h.in
index da7a98da7f..dddcc07da5 100644
--- a/libs/glibmm2/glibmmconfig.h.in
+++ b/libs/glibmm2/glibmmconfig.h.in
@@ -17,7 +17,6 @@
 #define GLIBMM_CONFIGURE
 #elif defined(__MINGW32__)
 #define GLIBMM_WIN32
-#define GLIBMM_DLL
 #define GLIBMM_CONFIGURE
 #else
 //AIX clR compiler complains about this even though it doesn't get this far:
@@ -28,6 +27,9 @@
 #endif /* _WIN32 */
 
 #ifdef GLIBMM_CONFIGURE
+/* compiler feature tests that are used during compile time and run-time
+   by gtk-- only. tests used by gdk-- and gtk-- should go into
+   gdk--config.h.in */
 #undef GLIBMM_CXX_HAVE_MUTABLE
 #undef GLIBMM_CXX_HAVE_NAMESPACES
 //#undef GLIBMM_CXX_GAUB
@@ -43,10 +45,6 @@
 #undef GLIBMM_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS
 #undef GLIBMM_CAN_USE_NAMESPACES_INSIDE_EXTERNC
 #undef GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS
-#undef GLIBMM_PROPERTIES_ENABLED
-#undef GLIBMM_VFUNCS_ENABLED
-#undef GLIBMM_EXCEPTIONS_ENABLED
-#undef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 #endif
 
 #ifdef GLIBMM_MSC
@@ -59,10 +57,7 @@
   #define GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION 1
   #define GLIBMM_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS 1
   #define GLIBMM_CAN_USE_NAMESPACES_INSIDE_EXTERNC 1
-  #define GLIBMM_PROPERTIES_ENABLED 1
-  #define GLIBMM_VFUNCS_ENABLED 1
-  #define GLIBMM_EXCEPTIONS_ENABLED 1
-  #define GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED 1
+  #define GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS 1
   #pragma warning (disable: 4786 4355 4800 4181)
 #endif
 
diff --git a/libs/glibmm2/macosx/English.lproj/InfoPlist.strings b/libs/glibmm2/macosx/English.lproj/InfoPlist.strings
deleted file mode 100644
index bbffddc6c4..0000000000
--- a/libs/glibmm2/macosx/English.lproj/InfoPlist.strings
+++ /dev/null
diff --git a/libs/glibmm2/macosx/Info.plist b/libs/glibmm2/macosx/Info.plist
deleted file mode 100644
index 268c6addaf..0000000000
--- a/libs/glibmm2/macosx/Info.plist
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>glibmm</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.apple.carbonframeworktemplate</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundlePackageType</key>
-	<string>FMWK</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string>1.0</string>
-        <key>CFBundleShortVersionString</key>
-        <string>1.01</string>
-	<key>CSResourcesFileMapped</key>
-	<true/>
-</dict>
-</plist>
diff --git a/libs/glibmm2/macosx/glibmm.xcodeproj/project.pbxproj b/libs/glibmm2/macosx/glibmm.xcodeproj/project.pbxproj
deleted file mode 100644
index 1b1789cc03..0000000000
--- a/libs/glibmm2/macosx/glibmm.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,818 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 42;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		69305D800B89598B00551B5A /* glibmm.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D7E0B89598B00551B5A /* glibmm.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305D810B89598B00551B5A /* glibmmconfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D7F0B89598B00551B5A /* glibmmconfig.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305DF80B89599B00551B5A /* arrayhandle.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D830B89599B00551B5A /* arrayhandle.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305DF90B89599B00551B5A /* class.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D840B89599B00551B5A /* class.cc */; };
-		69305DFA0B89599B00551B5A /* class.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D850B89599B00551B5A /* class.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305DFB0B89599B00551B5A /* containerhandle_shared.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D860B89599B00551B5A /* containerhandle_shared.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305DFC0B89599B00551B5A /* containers.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D870B89599B00551B5A /* containers.cc */; };
-		69305DFD0B89599B00551B5A /* containers.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D880B89599B00551B5A /* containers.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305DFE0B89599B00551B5A /* convert.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D890B89599B00551B5A /* convert.cc */; };
-		69305DFF0B89599B00551B5A /* convert.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D8A0B89599B00551B5A /* convert.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E000B89599B00551B5A /* date.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D8B0B89599B00551B5A /* date.cc */; };
-		69305E010B89599B00551B5A /* date.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D8C0B89599B00551B5A /* date.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E020B89599B00551B5A /* debug.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D8D0B89599B00551B5A /* debug.cc */; };
-		69305E030B89599B00551B5A /* debug.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D8E0B89599B00551B5A /* debug.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E040B89599B00551B5A /* dispatcher.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D8F0B89599B00551B5A /* dispatcher.cc */; };
-		69305E050B89599B00551B5A /* dispatcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D900B89599B00551B5A /* dispatcher.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E060B89599B00551B5A /* error.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D910B89599B00551B5A /* error.cc */; };
-		69305E070B89599B00551B5A /* error.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D920B89599B00551B5A /* error.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E080B89599B00551B5A /* exception.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D930B89599B00551B5A /* exception.cc */; };
-		69305E090B89599B00551B5A /* exception.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D940B89599B00551B5A /* exception.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E0A0B89599B00551B5A /* exceptionhandler.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D950B89599B00551B5A /* exceptionhandler.cc */; };
-		69305E0B0B89599B00551B5A /* exceptionhandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D960B89599B00551B5A /* exceptionhandler.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E0C0B89599B00551B5A /* fileutils.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D970B89599B00551B5A /* fileutils.cc */; };
-		69305E0D0B89599B00551B5A /* fileutils.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D980B89599B00551B5A /* fileutils.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E0E0B89599B00551B5A /* helperlist.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D990B89599B00551B5A /* helperlist.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E0F0B89599B00551B5A /* i18n.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D9A0B89599B00551B5A /* i18n.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E100B89599B00551B5A /* init.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D9B0B89599B00551B5A /* init.cc */; };
-		69305E110B89599B00551B5A /* init.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D9C0B89599B00551B5A /* init.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E120B89599B00551B5A /* interface.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D9D0B89599B00551B5A /* interface.cc */; };
-		69305E130B89599B00551B5A /* interface.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305D9E0B89599B00551B5A /* interface.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E140B89599B00551B5A /* iochannel.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305D9F0B89599B00551B5A /* iochannel.cc */; };
-		69305E150B89599B00551B5A /* iochannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DA00B89599B00551B5A /* iochannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E160B89599B00551B5A /* listhandle.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DA10B89599B00551B5A /* listhandle.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E170B89599B00551B5A /* main.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DA20B89599B00551B5A /* main.cc */; };
-		69305E180B89599B00551B5A /* main.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DA30B89599B00551B5A /* main.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E1A0B89599B00551B5A /* markup.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DA50B89599B00551B5A /* markup.cc */; };
-		69305E1B0B89599B00551B5A /* markup.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DA60B89599B00551B5A /* markup.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E1C0B89599B00551B5A /* miscutils.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DA70B89599B00551B5A /* miscutils.cc */; };
-		69305E1D0B89599B00551B5A /* miscutils.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DA80B89599B00551B5A /* miscutils.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E1E0B89599B00551B5A /* module.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DA90B89599B00551B5A /* module.cc */; };
-		69305E1F0B89599B00551B5A /* module.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DAA0B89599B00551B5A /* module.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E200B89599B00551B5A /* object.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DAB0B89599B00551B5A /* object.cc */; };
-		69305E210B89599B00551B5A /* object.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DAC0B89599B00551B5A /* object.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E220B89599B00551B5A /* objectbase.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DAD0B89599B00551B5A /* objectbase.cc */; };
-		69305E230B89599B00551B5A /* objectbase.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DAE0B89599B00551B5A /* objectbase.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E240B89599B00551B5A /* optioncontext.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DAF0B89599B00551B5A /* optioncontext.cc */; };
-		69305E250B89599B00551B5A /* optioncontext.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DB00B89599B00551B5A /* optioncontext.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E260B89599B00551B5A /* optionentry.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DB10B89599B00551B5A /* optionentry.cc */; };
-		69305E270B89599B00551B5A /* optionentry.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DB20B89599B00551B5A /* optionentry.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E280B89599B00551B5A /* optiongroup.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DB30B89599B00551B5A /* optiongroup.cc */; };
-		69305E290B89599B00551B5A /* optiongroup.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DB40B89599B00551B5A /* optiongroup.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E2A0B89599B00551B5A /* pattern.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DB50B89599B00551B5A /* pattern.cc */; };
-		69305E2B0B89599B00551B5A /* pattern.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DB60B89599B00551B5A /* pattern.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E2C0B89599B00551B5A /* convert_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DB80B89599B00551B5A /* convert_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E2D0B89599B00551B5A /* date_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DB90B89599B00551B5A /* date_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E2E0B89599B00551B5A /* fileutils_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DBA0B89599B00551B5A /* fileutils_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E2F0B89599B00551B5A /* interface_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DBB0B89599B00551B5A /* interface_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E300B89599B00551B5A /* iochannel_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DBC0B89599B00551B5A /* iochannel_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E310B89599B00551B5A /* markup_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DBD0B89599B00551B5A /* markup_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E320B89599B00551B5A /* module_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DBE0B89599B00551B5A /* module_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E330B89599B00551B5A /* object_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DBF0B89599B00551B5A /* object_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E340B89599B00551B5A /* optioncontext_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC00B89599B00551B5A /* optioncontext_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E350B89599B00551B5A /* optionentry_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC10B89599B00551B5A /* optionentry_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E360B89599B00551B5A /* optiongroup_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC20B89599B00551B5A /* optiongroup_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E370B89599B00551B5A /* shell_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC30B89599B00551B5A /* shell_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E380B89599B00551B5A /* spawn_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC40B89599B00551B5A /* spawn_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E390B89599B00551B5A /* thread_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC50B89599B00551B5A /* thread_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E3A0B89599B00551B5A /* unicode_p.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC60B89599B00551B5A /* unicode_p.h */; settings = {ATTRIBUTES = (); }; };
-		69305E3B0B89599B00551B5A /* property.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DC70B89599B00551B5A /* property.cc */; };
-		69305E3C0B89599B00551B5A /* property.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DC80B89599B00551B5A /* property.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E3D0B89599B00551B5A /* propertyproxy.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DC90B89599B00551B5A /* propertyproxy.cc */; };
-		69305E3E0B89599B00551B5A /* propertyproxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DCA0B89599B00551B5A /* propertyproxy.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E3F0B89599B00551B5A /* propertyproxy_base.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DCB0B89599B00551B5A /* propertyproxy_base.cc */; };
-		69305E400B89599B00551B5A /* propertyproxy_base.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DCC0B89599B00551B5A /* propertyproxy_base.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E410B89599B00551B5A /* quark.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DCD0B89599B00551B5A /* quark.cc */; };
-		69305E420B89599B00551B5A /* quark.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DCE0B89599B00551B5A /* quark.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E430B89599B00551B5A /* random.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DCF0B89599B00551B5A /* random.cc */; };
-		69305E440B89599B00551B5A /* random.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DD00B89599B00551B5A /* random.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E450B89599B00551B5A /* refptr.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DD10B89599B00551B5A /* refptr.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E460B89599B00551B5A /* sarray.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DD20B89599B00551B5A /* sarray.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E470B89599B00551B5A /* shell.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DD30B89599B00551B5A /* shell.cc */; };
-		69305E480B89599B00551B5A /* shell.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DD40B89599B00551B5A /* shell.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E490B89599B00551B5A /* signalproxy.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DD50B89599B00551B5A /* signalproxy.cc */; };
-		69305E4A0B89599B00551B5A /* signalproxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DD60B89599B00551B5A /* signalproxy.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E4B0B89599B00551B5A /* signalproxy_connectionnode.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DD70B89599B00551B5A /* signalproxy_connectionnode.cc */; };
-		69305E4C0B89599B00551B5A /* signalproxy_connectionnode.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DD80B89599B00551B5A /* signalproxy_connectionnode.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E4D0B89599B00551B5A /* slisthandle.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DD90B89599B00551B5A /* slisthandle.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E4E0B89599B00551B5A /* spawn.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DDA0B89599B00551B5A /* spawn.cc */; };
-		69305E4F0B89599B00551B5A /* spawn.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DDB0B89599B00551B5A /* spawn.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E500B89599B00551B5A /* streamiochannel.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DDC0B89599B00551B5A /* streamiochannel.cc */; };
-		69305E510B89599B00551B5A /* streamiochannel.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DDD0B89599B00551B5A /* streamiochannel.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E520B89599B00551B5A /* stringutils.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DDE0B89599B00551B5A /* stringutils.cc */; };
-		69305E530B89599B00551B5A /* stringutils.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DDF0B89599B00551B5A /* stringutils.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E540B89599B00551B5A /* thread.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DE00B89599B00551B5A /* thread.cc */; };
-		69305E550B89599B00551B5A /* thread.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DE10B89599B00551B5A /* thread.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E560B89599B00551B5A /* threadpool.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DE20B89599B00551B5A /* threadpool.cc */; };
-		69305E570B89599B00551B5A /* threadpool.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DE30B89599B00551B5A /* threadpool.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E580B89599B00551B5A /* timer.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DE40B89599B00551B5A /* timer.cc */; };
-		69305E590B89599B00551B5A /* timer.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DE50B89599B00551B5A /* timer.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E5A0B89599B00551B5A /* timeval.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DE60B89599B00551B5A /* timeval.cc */; };
-		69305E5B0B89599B00551B5A /* timeval.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DE70B89599B00551B5A /* timeval.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E5C0B89599B00551B5A /* unicode.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DE80B89599B00551B5A /* unicode.cc */; };
-		69305E5D0B89599B00551B5A /* unicode.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DE90B89599B00551B5A /* unicode.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E5E0B89599B00551B5A /* ustring.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DEA0B89599B00551B5A /* ustring.cc */; };
-		69305E5F0B89599B00551B5A /* ustring.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DEB0B89599B00551B5A /* ustring.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E600B89599B00551B5A /* utility.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DEC0B89599B00551B5A /* utility.cc */; };
-		69305E610B89599B00551B5A /* utility.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DED0B89599B00551B5A /* utility.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E620B89599B00551B5A /* value.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DEE0B89599B00551B5A /* value.cc */; };
-		69305E630B89599B00551B5A /* value.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DEF0B89599B00551B5A /* value.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E640B89599B00551B5A /* value_basictypes.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DF00B89599B00551B5A /* value_basictypes.cc */; };
-		69305E650B89599B00551B5A /* value_basictypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DF10B89599B00551B5A /* value_basictypes.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E660B89599B00551B5A /* value_custom.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DF20B89599B00551B5A /* value_custom.cc */; };
-		69305E670B89599B00551B5A /* value_custom.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DF30B89599B00551B5A /* value_custom.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E680B89599B00551B5A /* wrap.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DF40B89599B00551B5A /* wrap.cc */; };
-		69305E690B89599B00551B5A /* wrap.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DF50B89599B00551B5A /* wrap.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69305E6A0B89599B00551B5A /* wrap_init.cc in Sources */ = {isa = PBXBuildFile; fileRef = 69305DF60B89599B00551B5A /* wrap_init.cc */; };
-		69305E6B0B89599B00551B5A /* wrap_init.h in Headers */ = {isa = PBXBuildFile; fileRef = 69305DF70B89599B00551B5A /* wrap_init.h */; settings = {ATTRIBUTES = (Public, ); }; };
-		69E898600B8A2D5B000A74EF /* sigc.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 69E8985F0B8A2D5B000A74EF /* sigc.framework */; };
-		69E8986A0B8A2F0D000A74EF /* libglib-2.0.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 69E898660B8A2F0D000A74EF /* libglib-2.0.dylib */; };
-		69E8986B0B8A2F0D000A74EF /* libgmodule-2.0.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 69E898670B8A2F0D000A74EF /* libgmodule-2.0.dylib */; };
-		69E8986C0B8A2F0D000A74EF /* libgobject-2.0.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 69E898680B8A2F0D000A74EF /* libgobject-2.0.dylib */; };
-		69E8986D0B8A2F0D000A74EF /* libgthread-2.0.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 69E898690B8A2F0D000A74EF /* libgthread-2.0.dylib */; };
-		8D07F2BE0486CC7A007CD1D0 /* glibmm_Prefix.pch in Headers */ = {isa = PBXBuildFile; fileRef = 32BAE0B70371A74B00C91783 /* glibmm_Prefix.pch */; settings = {ATTRIBUTES = (Public, ); }; };
-		8D07F2C00486CC7A007CD1D0 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C1666FE841158C02AAC07 /* InfoPlist.strings */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXFileReference section */
-		089C1667FE841158C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
-		32BAE0B70371A74B00C91783 /* glibmm_Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = glibmm_Prefix.pch; sourceTree = "<group>"; };
-		69305D7E0B89598B00551B5A /* glibmm.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = glibmm.h; path = ../glibmm.h; sourceTree = SOURCE_ROOT; };
-		69305D7F0B89598B00551B5A /* glibmmconfig.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = glibmmconfig.h; path = ../glibmmconfig.h; sourceTree = SOURCE_ROOT; };
-		69305D830B89599B00551B5A /* arrayhandle.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = arrayhandle.h; sourceTree = "<group>"; };
-		69305D840B89599B00551B5A /* class.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = class.cc; sourceTree = "<group>"; };
-		69305D850B89599B00551B5A /* class.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = class.h; sourceTree = "<group>"; };
-		69305D860B89599B00551B5A /* containerhandle_shared.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = containerhandle_shared.h; sourceTree = "<group>"; };
-		69305D870B89599B00551B5A /* containers.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = containers.cc; sourceTree = "<group>"; };
-		69305D880B89599B00551B5A /* containers.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = containers.h; sourceTree = "<group>"; };
-		69305D890B89599B00551B5A /* convert.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = convert.cc; sourceTree = "<group>"; };
-		69305D8A0B89599B00551B5A /* convert.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = convert.h; sourceTree = "<group>"; };
-		69305D8B0B89599B00551B5A /* date.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = date.cc; sourceTree = "<group>"; };
-		69305D8C0B89599B00551B5A /* date.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = date.h; sourceTree = "<group>"; };
-		69305D8D0B89599B00551B5A /* debug.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = debug.cc; sourceTree = "<group>"; };
-		69305D8E0B89599B00551B5A /* debug.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = debug.h; sourceTree = "<group>"; };
-		69305D8F0B89599B00551B5A /* dispatcher.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = dispatcher.cc; sourceTree = "<group>"; };
-		69305D900B89599B00551B5A /* dispatcher.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = dispatcher.h; sourceTree = "<group>"; };
-		69305D910B89599B00551B5A /* error.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = error.cc; sourceTree = "<group>"; };
-		69305D920B89599B00551B5A /* error.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = error.h; sourceTree = "<group>"; };
-		69305D930B89599B00551B5A /* exception.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = exception.cc; sourceTree = "<group>"; };
-		69305D940B89599B00551B5A /* exception.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = exception.h; sourceTree = "<group>"; };
-		69305D950B89599B00551B5A /* exceptionhandler.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = exceptionhandler.cc; sourceTree = "<group>"; };
-		69305D960B89599B00551B5A /* exceptionhandler.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = exceptionhandler.h; sourceTree = "<group>"; };
-		69305D970B89599B00551B5A /* fileutils.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = fileutils.cc; sourceTree = "<group>"; };
-		69305D980B89599B00551B5A /* fileutils.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = fileutils.h; sourceTree = "<group>"; };
-		69305D990B89599B00551B5A /* helperlist.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = helperlist.h; sourceTree = "<group>"; };
-		69305D9A0B89599B00551B5A /* i18n.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = i18n.h; sourceTree = "<group>"; };
-		69305D9B0B89599B00551B5A /* init.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = init.cc; sourceTree = "<group>"; };
-		69305D9C0B89599B00551B5A /* init.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = init.h; sourceTree = "<group>"; };
-		69305D9D0B89599B00551B5A /* interface.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = interface.cc; sourceTree = "<group>"; };
-		69305D9E0B89599B00551B5A /* interface.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = interface.h; sourceTree = "<group>"; };
-		69305D9F0B89599B00551B5A /* iochannel.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = iochannel.cc; sourceTree = "<group>"; };
-		69305DA00B89599B00551B5A /* iochannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = iochannel.h; sourceTree = "<group>"; };
-		69305DA10B89599B00551B5A /* listhandle.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = listhandle.h; sourceTree = "<group>"; };
-		69305DA20B89599B00551B5A /* main.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = main.cc; sourceTree = "<group>"; };
-		69305DA30B89599B00551B5A /* main.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = main.h; sourceTree = "<group>"; };
-		69305DA50B89599B00551B5A /* markup.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = markup.cc; sourceTree = "<group>"; };
-		69305DA60B89599B00551B5A /* markup.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = markup.h; sourceTree = "<group>"; };
-		69305DA70B89599B00551B5A /* miscutils.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = miscutils.cc; sourceTree = "<group>"; };
-		69305DA80B89599B00551B5A /* miscutils.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = miscutils.h; sourceTree = "<group>"; };
-		69305DA90B89599B00551B5A /* module.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = module.cc; sourceTree = "<group>"; };
-		69305DAA0B89599B00551B5A /* module.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = module.h; sourceTree = "<group>"; };
-		69305DAB0B89599B00551B5A /* object.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = object.cc; sourceTree = "<group>"; };
-		69305DAC0B89599B00551B5A /* object.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = object.h; sourceTree = "<group>"; };
-		69305DAD0B89599B00551B5A /* objectbase.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = objectbase.cc; sourceTree = "<group>"; };
-		69305DAE0B89599B00551B5A /* objectbase.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = objectbase.h; sourceTree = "<group>"; };
-		69305DAF0B89599B00551B5A /* optioncontext.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = optioncontext.cc; sourceTree = "<group>"; };
-		69305DB00B89599B00551B5A /* optioncontext.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = optioncontext.h; sourceTree = "<group>"; };
-		69305DB10B89599B00551B5A /* optionentry.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = optionentry.cc; sourceTree = "<group>"; };
-		69305DB20B89599B00551B5A /* optionentry.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = optionentry.h; sourceTree = "<group>"; };
-		69305DB30B89599B00551B5A /* optiongroup.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = optiongroup.cc; sourceTree = "<group>"; };
-		69305DB40B89599B00551B5A /* optiongroup.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = optiongroup.h; sourceTree = "<group>"; };
-		69305DB50B89599B00551B5A /* pattern.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = pattern.cc; sourceTree = "<group>"; };
-		69305DB60B89599B00551B5A /* pattern.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = pattern.h; sourceTree = "<group>"; };
-		69305DB80B89599B00551B5A /* convert_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = convert_p.h; sourceTree = "<group>"; };
-		69305DB90B89599B00551B5A /* date_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = date_p.h; sourceTree = "<group>"; };
-		69305DBA0B89599B00551B5A /* fileutils_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = fileutils_p.h; sourceTree = "<group>"; };
-		69305DBB0B89599B00551B5A /* interface_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = interface_p.h; sourceTree = "<group>"; };
-		69305DBC0B89599B00551B5A /* iochannel_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = iochannel_p.h; sourceTree = "<group>"; };
-		69305DBD0B89599B00551B5A /* markup_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = markup_p.h; sourceTree = "<group>"; };
-		69305DBE0B89599B00551B5A /* module_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = module_p.h; sourceTree = "<group>"; };
-		69305DBF0B89599B00551B5A /* object_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = object_p.h; sourceTree = "<group>"; };
-		69305DC00B89599B00551B5A /* optioncontext_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = optioncontext_p.h; sourceTree = "<group>"; };
-		69305DC10B89599B00551B5A /* optionentry_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = optionentry_p.h; sourceTree = "<group>"; };
-		69305DC20B89599B00551B5A /* optiongroup_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = optiongroup_p.h; sourceTree = "<group>"; };
-		69305DC30B89599B00551B5A /* shell_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = shell_p.h; sourceTree = "<group>"; };
-		69305DC40B89599B00551B5A /* spawn_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = spawn_p.h; sourceTree = "<group>"; };
-		69305DC50B89599B00551B5A /* thread_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = thread_p.h; sourceTree = "<group>"; };
-		69305DC60B89599B00551B5A /* unicode_p.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = unicode_p.h; sourceTree = "<group>"; };
-		69305DC70B89599B00551B5A /* property.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = property.cc; sourceTree = "<group>"; };
-		69305DC80B89599B00551B5A /* property.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = property.h; sourceTree = "<group>"; };
-		69305DC90B89599B00551B5A /* propertyproxy.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = propertyproxy.cc; sourceTree = "<group>"; };
-		69305DCA0B89599B00551B5A /* propertyproxy.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = propertyproxy.h; sourceTree = "<group>"; };
-		69305DCB0B89599B00551B5A /* propertyproxy_base.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = propertyproxy_base.cc; sourceTree = "<group>"; };
-		69305DCC0B89599B00551B5A /* propertyproxy_base.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = propertyproxy_base.h; sourceTree = "<group>"; };
-		69305DCD0B89599B00551B5A /* quark.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = quark.cc; sourceTree = "<group>"; };
-		69305DCE0B89599B00551B5A /* quark.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = quark.h; sourceTree = "<group>"; };
-		69305DCF0B89599B00551B5A /* random.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = random.cc; sourceTree = "<group>"; };
-		69305DD00B89599B00551B5A /* random.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = random.h; sourceTree = "<group>"; };
-		69305DD10B89599B00551B5A /* refptr.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = refptr.h; sourceTree = "<group>"; };
-		69305DD20B89599B00551B5A /* sarray.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = sarray.h; sourceTree = "<group>"; };
-		69305DD30B89599B00551B5A /* shell.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = shell.cc; sourceTree = "<group>"; };
-		69305DD40B89599B00551B5A /* shell.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = shell.h; sourceTree = "<group>"; };
-		69305DD50B89599B00551B5A /* signalproxy.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = signalproxy.cc; sourceTree = "<group>"; };
-		69305DD60B89599B00551B5A /* signalproxy.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = signalproxy.h; sourceTree = "<group>"; };
-		69305DD70B89599B00551B5A /* signalproxy_connectionnode.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = signalproxy_connectionnode.cc; sourceTree = "<group>"; };
-		69305DD80B89599B00551B5A /* signalproxy_connectionnode.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = signalproxy_connectionnode.h; sourceTree = "<group>"; };
-		69305DD90B89599B00551B5A /* slisthandle.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = slisthandle.h; sourceTree = "<group>"; };
-		69305DDA0B89599B00551B5A /* spawn.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = spawn.cc; sourceTree = "<group>"; };
-		69305DDB0B89599B00551B5A /* spawn.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = spawn.h; sourceTree = "<group>"; };
-		69305DDC0B89599B00551B5A /* streamiochannel.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = streamiochannel.cc; sourceTree = "<group>"; };
-		69305DDD0B89599B00551B5A /* streamiochannel.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = streamiochannel.h; sourceTree = "<group>"; };
-		69305DDE0B89599B00551B5A /* stringutils.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = stringutils.cc; sourceTree = "<group>"; };
-		69305DDF0B89599B00551B5A /* stringutils.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = stringutils.h; sourceTree = "<group>"; };
-		69305DE00B89599B00551B5A /* thread.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = thread.cc; sourceTree = "<group>"; };
-		69305DE10B89599B00551B5A /* thread.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = thread.h; sourceTree = "<group>"; };
-		69305DE20B89599B00551B5A /* threadpool.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = threadpool.cc; sourceTree = "<group>"; };
-		69305DE30B89599B00551B5A /* threadpool.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = threadpool.h; sourceTree = "<group>"; };
-		69305DE40B89599B00551B5A /* timer.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = timer.cc; sourceTree = "<group>"; };
-		69305DE50B89599B00551B5A /* timer.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = timer.h; sourceTree = "<group>"; };
-		69305DE60B89599B00551B5A /* timeval.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = timeval.cc; sourceTree = "<group>"; };
-		69305DE70B89599B00551B5A /* timeval.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = timeval.h; sourceTree = "<group>"; };
-		69305DE80B89599B00551B5A /* unicode.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = unicode.cc; sourceTree = "<group>"; };
-		69305DE90B89599B00551B5A /* unicode.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = unicode.h; sourceTree = "<group>"; };
-		69305DEA0B89599B00551B5A /* ustring.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ustring.cc; sourceTree = "<group>"; };
-		69305DEB0B89599B00551B5A /* ustring.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ustring.h; sourceTree = "<group>"; };
-		69305DEC0B89599B00551B5A /* utility.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = utility.cc; sourceTree = "<group>"; };
-		69305DED0B89599B00551B5A /* utility.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = utility.h; sourceTree = "<group>"; };
-		69305DEE0B89599B00551B5A /* value.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = value.cc; sourceTree = "<group>"; };
-		69305DEF0B89599B00551B5A /* value.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = value.h; sourceTree = "<group>"; };
-		69305DF00B89599B00551B5A /* value_basictypes.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = value_basictypes.cc; sourceTree = "<group>"; };
-		69305DF10B89599B00551B5A /* value_basictypes.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = value_basictypes.h; sourceTree = "<group>"; };
-		69305DF20B89599B00551B5A /* value_custom.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = value_custom.cc; sourceTree = "<group>"; };
-		69305DF30B89599B00551B5A /* value_custom.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = value_custom.h; sourceTree = "<group>"; };
-		69305DF40B89599B00551B5A /* wrap.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = wrap.cc; sourceTree = "<group>"; };
-		69305DF50B89599B00551B5A /* wrap.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = wrap.h; sourceTree = "<group>"; };
-		69305DF60B89599B00551B5A /* wrap_init.cc */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = wrap_init.cc; sourceTree = "<group>"; };
-		69305DF70B89599B00551B5A /* wrap_init.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = wrap_init.h; sourceTree = "<group>"; };
-		69E8985F0B8A2D5B000A74EF /* sigc.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = sigc.framework; path = /Library/Frameworks/sigc.framework; sourceTree = "<absolute>"; };
-		69E898660B8A2F0D000A74EF /* libglib-2.0.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = "libglib-2.0.dylib"; path = "/Library/Frameworks/GLib.framework/Versions/2.12.3/Libraries/libglib-2.0.dylib"; sourceTree = "<absolute>"; };
-		69E898670B8A2F0D000A74EF /* libgmodule-2.0.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = "libgmodule-2.0.dylib"; path = "/Library/Frameworks/GLib.framework/Versions/2.12.3/Libraries/libgmodule-2.0.dylib"; sourceTree = "<absolute>"; };
-		69E898680B8A2F0D000A74EF /* libgobject-2.0.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = "libgobject-2.0.dylib"; path = "/Library/Frameworks/GLib.framework/Versions/2.12.3/Libraries/libgobject-2.0.dylib"; sourceTree = "<absolute>"; };
-		69E898690B8A2F0D000A74EF /* libgthread-2.0.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = "libgthread-2.0.dylib"; path = "/Library/Frameworks/GLib.framework/Versions/2.12.3/Libraries/libgthread-2.0.dylib"; sourceTree = "<absolute>"; };
-		8D07F2C70486CC7A007CD1D0 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
-		8D07F2C80486CC7A007CD1D0 /* glibmm.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = glibmm.framework; sourceTree = BUILT_PRODUCTS_DIR; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		8D07F2C30486CC7A007CD1D0 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				69E898600B8A2D5B000A74EF /* sigc.framework in Frameworks */,
-				69E8986A0B8A2F0D000A74EF /* libglib-2.0.dylib in Frameworks */,
-				69E8986B0B8A2F0D000A74EF /* libgmodule-2.0.dylib in Frameworks */,
-				69E8986C0B8A2F0D000A74EF /* libgobject-2.0.dylib in Frameworks */,
-				69E8986D0B8A2F0D000A74EF /* libgthread-2.0.dylib in Frameworks */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		034768DDFF38A45A11DB9C8B /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				8D07F2C80486CC7A007CD1D0 /* glibmm.framework */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		0867D691FE84028FC02AAC07 /* glibmm */ = {
-			isa = PBXGroup;
-			children = (
-				08FB77ACFE841707C02AAC07 /* Source */,
-				089C1665FE841158C02AAC07 /* Resources */,
-				0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */,
-				034768DDFF38A45A11DB9C8B /* Products */,
-			);
-			name = glibmm;
-			sourceTree = "<group>";
-		};
-		0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */ = {
-			isa = PBXGroup;
-			children = (
-				69E898660B8A2F0D000A74EF /* libglib-2.0.dylib */,
-				69E898670B8A2F0D000A74EF /* libgmodule-2.0.dylib */,
-				69E898680B8A2F0D000A74EF /* libgobject-2.0.dylib */,
-				69E898690B8A2F0D000A74EF /* libgthread-2.0.dylib */,
-				69E8985F0B8A2D5B000A74EF /* sigc.framework */,
-			);
-			name = "External Frameworks and Libraries";
-			sourceTree = "<group>";
-		};
-		089C1665FE841158C02AAC07 /* Resources */ = {
-			isa = PBXGroup;
-			children = (
-				8D07F2C70486CC7A007CD1D0 /* Info.plist */,
-				089C1666FE841158C02AAC07 /* InfoPlist.strings */,
-			);
-			name = Resources;
-			sourceTree = "<group>";
-		};
-		08FB77ACFE841707C02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				69305D820B89599B00551B5A /* glibmm */,
-				69305D7E0B89598B00551B5A /* glibmm.h */,
-				69305D7F0B89598B00551B5A /* glibmmconfig.h */,
-				32BAE0B70371A74B00C91783 /* glibmm_Prefix.pch */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		69305D820B89599B00551B5A /* glibmm */ = {
-			isa = PBXGroup;
-			children = (
-				69305D830B89599B00551B5A /* arrayhandle.h */,
-				69305D840B89599B00551B5A /* class.cc */,
-				69305D850B89599B00551B5A /* class.h */,
-				69305D860B89599B00551B5A /* containerhandle_shared.h */,
-				69305D870B89599B00551B5A /* containers.cc */,
-				69305D880B89599B00551B5A /* containers.h */,
-				69305D890B89599B00551B5A /* convert.cc */,
-				69305D8A0B89599B00551B5A /* convert.h */,
-				69305D8B0B89599B00551B5A /* date.cc */,
-				69305D8C0B89599B00551B5A /* date.h */,
-				69305D8D0B89599B00551B5A /* debug.cc */,
-				69305D8E0B89599B00551B5A /* debug.h */,
-				69305D8F0B89599B00551B5A /* dispatcher.cc */,
-				69305D900B89599B00551B5A /* dispatcher.h */,
-				69305D910B89599B00551B5A /* error.cc */,
-				69305D920B89599B00551B5A /* error.h */,
-				69305D930B89599B00551B5A /* exception.cc */,
-				69305D940B89599B00551B5A /* exception.h */,
-				69305D950B89599B00551B5A /* exceptionhandler.cc */,
-				69305D960B89599B00551B5A /* exceptionhandler.h */,
-				69305D970B89599B00551B5A /* fileutils.cc */,
-				69305D980B89599B00551B5A /* fileutils.h */,
-				69305D990B89599B00551B5A /* helperlist.h */,
-				69305D9A0B89599B00551B5A /* i18n.h */,
-				69305D9B0B89599B00551B5A /* init.cc */,
-				69305D9C0B89599B00551B5A /* init.h */,
-				69305D9D0B89599B00551B5A /* interface.cc */,
-				69305D9E0B89599B00551B5A /* interface.h */,
-				69305D9F0B89599B00551B5A /* iochannel.cc */,
-				69305DA00B89599B00551B5A /* iochannel.h */,
-				69305DA10B89599B00551B5A /* listhandle.h */,
-				69305DA20B89599B00551B5A /* main.cc */,
-				69305DA30B89599B00551B5A /* main.h */,
-				69305DA50B89599B00551B5A /* markup.cc */,
-				69305DA60B89599B00551B5A /* markup.h */,
-				69305DA70B89599B00551B5A /* miscutils.cc */,
-				69305DA80B89599B00551B5A /* miscutils.h */,
-				69305DA90B89599B00551B5A /* module.cc */,
-				69305DAA0B89599B00551B5A /* module.h */,
-				69305DAB0B89599B00551B5A /* object.cc */,
-				69305DAC0B89599B00551B5A /* object.h */,
-				69305DAD0B89599B00551B5A /* objectbase.cc */,
-				69305DAE0B89599B00551B5A /* objectbase.h */,
-				69305DAF0B89599B00551B5A /* optioncontext.cc */,
-				69305DB00B89599B00551B5A /* optioncontext.h */,
-				69305DB10B89599B00551B5A /* optionentry.cc */,
-				69305DB20B89599B00551B5A /* optionentry.h */,
-				69305DB30B89599B00551B5A /* optiongroup.cc */,
-				69305DB40B89599B00551B5A /* optiongroup.h */,
-				69305DB50B89599B00551B5A /* pattern.cc */,
-				69305DB60B89599B00551B5A /* pattern.h */,
-				69305DB70B89599B00551B5A /* private */,
-				69305DC70B89599B00551B5A /* property.cc */,
-				69305DC80B89599B00551B5A /* property.h */,
-				69305DC90B89599B00551B5A /* propertyproxy.cc */,
-				69305DCA0B89599B00551B5A /* propertyproxy.h */,
-				69305DCB0B89599B00551B5A /* propertyproxy_base.cc */,
-				69305DCC0B89599B00551B5A /* propertyproxy_base.h */,
-				69305DCD0B89599B00551B5A /* quark.cc */,
-				69305DCE0B89599B00551B5A /* quark.h */,
-				69305DCF0B89599B00551B5A /* random.cc */,
-				69305DD00B89599B00551B5A /* random.h */,
-				69305DD10B89599B00551B5A /* refptr.h */,
-				69305DD20B89599B00551B5A /* sarray.h */,
-				69305DD30B89599B00551B5A /* shell.cc */,
-				69305DD40B89599B00551B5A /* shell.h */,
-				69305DD50B89599B00551B5A /* signalproxy.cc */,
-				69305DD60B89599B00551B5A /* signalproxy.h */,
-				69305DD70B89599B00551B5A /* signalproxy_connectionnode.cc */,
-				69305DD80B89599B00551B5A /* signalproxy_connectionnode.h */,
-				69305DD90B89599B00551B5A /* slisthandle.h */,
-				69305DDA0B89599B00551B5A /* spawn.cc */,
-				69305DDB0B89599B00551B5A /* spawn.h */,
-				69305DDC0B89599B00551B5A /* streamiochannel.cc */,
-				69305DDD0B89599B00551B5A /* streamiochannel.h */,
-				69305DDE0B89599B00551B5A /* stringutils.cc */,
-				69305DDF0B89599B00551B5A /* stringutils.h */,
-				69305DE00B89599B00551B5A /* thread.cc */,
-				69305DE10B89599B00551B5A /* thread.h */,
-				69305DE20B89599B00551B5A /* threadpool.cc */,
-				69305DE30B89599B00551B5A /* threadpool.h */,
-				69305DE40B89599B00551B5A /* timer.cc */,
-				69305DE50B89599B00551B5A /* timer.h */,
-				69305DE60B89599B00551B5A /* timeval.cc */,
-				69305DE70B89599B00551B5A /* timeval.h */,
-				69305DE80B89599B00551B5A /* unicode.cc */,
-				69305DE90B89599B00551B5A /* unicode.h */,
-				69305DEA0B89599B00551B5A /* ustring.cc */,
-				69305DEB0B89599B00551B5A /* ustring.h */,
-				69305DEC0B89599B00551B5A /* utility.cc */,
-				69305DED0B89599B00551B5A /* utility.h */,
-				69305DEE0B89599B00551B5A /* value.cc */,
-				69305DEF0B89599B00551B5A /* value.h */,
-				69305DF00B89599B00551B5A /* value_basictypes.cc */,
-				69305DF10B89599B00551B5A /* value_basictypes.h */,
-				69305DF20B89599B00551B5A /* value_custom.cc */,
-				69305DF30B89599B00551B5A /* value_custom.h */,
-				69305DF40B89599B00551B5A /* wrap.cc */,
-				69305DF50B89599B00551B5A /* wrap.h */,
-				69305DF60B89599B00551B5A /* wrap_init.cc */,
-				69305DF70B89599B00551B5A /* wrap_init.h */,
-			);
-			name = glibmm;
-			path = ../glibmm;
-			sourceTree = SOURCE_ROOT;
-		};
-		69305DB70B89599B00551B5A /* private */ = {
-			isa = PBXGroup;
-			children = (
-				69305DB80B89599B00551B5A /* convert_p.h */,
-				69305DB90B89599B00551B5A /* date_p.h */,
-				69305DBA0B89599B00551B5A /* fileutils_p.h */,
-				69305DBB0B89599B00551B5A /* interface_p.h */,
-				69305DBC0B89599B00551B5A /* iochannel_p.h */,
-				69305DBD0B89599B00551B5A /* markup_p.h */,
-				69305DBE0B89599B00551B5A /* module_p.h */,
-				69305DBF0B89599B00551B5A /* object_p.h */,
-				69305DC00B89599B00551B5A /* optioncontext_p.h */,
-				69305DC10B89599B00551B5A /* optionentry_p.h */,
-				69305DC20B89599B00551B5A /* optiongroup_p.h */,
-				69305DC30B89599B00551B5A /* shell_p.h */,
-				69305DC40B89599B00551B5A /* spawn_p.h */,
-				69305DC50B89599B00551B5A /* thread_p.h */,
-				69305DC60B89599B00551B5A /* unicode_p.h */,
-			);
-			path = private;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXHeadersBuildPhase section */
-		8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
-			isa = PBXHeadersBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D07F2BE0486CC7A007CD1D0 /* glibmm_Prefix.pch in Headers */,
-				69305D800B89598B00551B5A /* glibmm.h in Headers */,
-				69305D810B89598B00551B5A /* glibmmconfig.h in Headers */,
-				69305DF80B89599B00551B5A /* arrayhandle.h in Headers */,
-				69305DFA0B89599B00551B5A /* class.h in Headers */,
-				69305DFB0B89599B00551B5A /* containerhandle_shared.h in Headers */,
-				69305DFD0B89599B00551B5A /* containers.h in Headers */,
-				69305DFF0B89599B00551B5A /* convert.h in Headers */,
-				69305E010B89599B00551B5A /* date.h in Headers */,
-				69305E030B89599B00551B5A /* debug.h in Headers */,
-				69305E050B89599B00551B5A /* dispatcher.h in Headers */,
-				69305E070B89599B00551B5A /* error.h in Headers */,
-				69305E090B89599B00551B5A /* exception.h in Headers */,
-				69305E0B0B89599B00551B5A /* exceptionhandler.h in Headers */,
-				69305E0D0B89599B00551B5A /* fileutils.h in Headers */,
-				69305E0E0B89599B00551B5A /* helperlist.h in Headers */,
-				69305E0F0B89599B00551B5A /* i18n.h in Headers */,
-				69305E110B89599B00551B5A /* init.h in Headers */,
-				69305E130B89599B00551B5A /* interface.h in Headers */,
-				69305E150B89599B00551B5A /* iochannel.h in Headers */,
-				69305E160B89599B00551B5A /* listhandle.h in Headers */,
-				69305E180B89599B00551B5A /* main.h in Headers */,
-				69305E1B0B89599B00551B5A /* markup.h in Headers */,
-				69305E1D0B89599B00551B5A /* miscutils.h in Headers */,
-				69305E1F0B89599B00551B5A /* module.h in Headers */,
-				69305E210B89599B00551B5A /* object.h in Headers */,
-				69305E230B89599B00551B5A /* objectbase.h in Headers */,
-				69305E250B89599B00551B5A /* optioncontext.h in Headers */,
-				69305E270B89599B00551B5A /* optionentry.h in Headers */,
-				69305E290B89599B00551B5A /* optiongroup.h in Headers */,
-				69305E2B0B89599B00551B5A /* pattern.h in Headers */,
-				69305E2C0B89599B00551B5A /* convert_p.h in Headers */,
-				69305E2D0B89599B00551B5A /* date_p.h in Headers */,
-				69305E2E0B89599B00551B5A /* fileutils_p.h in Headers */,
-				69305E2F0B89599B00551B5A /* interface_p.h in Headers */,
-				69305E300B89599B00551B5A /* iochannel_p.h in Headers */,
-				69305E310B89599B00551B5A /* markup_p.h in Headers */,
-				69305E320B89599B00551B5A /* module_p.h in Headers */,
-				69305E330B89599B00551B5A /* object_p.h in Headers */,
-				69305E340B89599B00551B5A /* optioncontext_p.h in Headers */,
-				69305E350B89599B00551B5A /* optionentry_p.h in Headers */,
-				69305E360B89599B00551B5A /* optiongroup_p.h in Headers */,
-				69305E370B89599B00551B5A /* shell_p.h in Headers */,
-				69305E380B89599B00551B5A /* spawn_p.h in Headers */,
-				69305E390B89599B00551B5A /* thread_p.h in Headers */,
-				69305E3A0B89599B00551B5A /* unicode_p.h in Headers */,
-				69305E3C0B89599B00551B5A /* property.h in Headers */,
-				69305E3E0B89599B00551B5A /* propertyproxy.h in Headers */,
-				69305E400B89599B00551B5A /* propertyproxy_base.h in Headers */,
-				69305E420B89599B00551B5A /* quark.h in Headers */,
-				69305E440B89599B00551B5A /* random.h in Headers */,
-				69305E450B89599B00551B5A /* refptr.h in Headers */,
-				69305E460B89599B00551B5A /* sarray.h in Headers */,
-				69305E480B89599B00551B5A /* shell.h in Headers */,
-				69305E4A0B89599B00551B5A /* signalproxy.h in Headers */,
-				69305E4C0B89599B00551B5A /* signalproxy_connectionnode.h in Headers */,
-				69305E4D0B89599B00551B5A /* slisthandle.h in Headers */,
-				69305E4F0B89599B00551B5A /* spawn.h in Headers */,
-				69305E510B89599B00551B5A /* streamiochannel.h in Headers */,
-				69305E530B89599B00551B5A /* stringutils.h in Headers */,
-				69305E550B89599B00551B5A /* thread.h in Headers */,
-				69305E570B89599B00551B5A /* threadpool.h in Headers */,
-				69305E590B89599B00551B5A /* timer.h in Headers */,
-				69305E5B0B89599B00551B5A /* timeval.h in Headers */,
-				69305E5D0B89599B00551B5A /* unicode.h in Headers */,
-				69305E5F0B89599B00551B5A /* ustring.h in Headers */,
-				69305E610B89599B00551B5A /* utility.h in Headers */,
-				69305E630B89599B00551B5A /* value.h in Headers */,
-				69305E650B89599B00551B5A /* value_basictypes.h in Headers */,
-				69305E670B89599B00551B5A /* value_custom.h in Headers */,
-				69305E690B89599B00551B5A /* wrap.h in Headers */,
-				69305E6B0B89599B00551B5A /* wrap_init.h in Headers */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXHeadersBuildPhase section */
-
-/* Begin PBXNativeTarget section */
-		8D07F2BC0486CC7A007CD1D0 /* glibmm */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "glibmm" */;
-			buildPhases = (
-				8D07F2BD0486CC7A007CD1D0 /* Headers */,
-				8D07F2BF0486CC7A007CD1D0 /* Resources */,
-				8D07F2C10486CC7A007CD1D0 /* Sources */,
-				8D07F2C30486CC7A007CD1D0 /* Frameworks */,
-				8D07F2C50486CC7A007CD1D0 /* Rez */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = glibmm;
-			productInstallPath = "$(HOME)/Library/Frameworks";
-			productName = glibmm;
-			productReference = 8D07F2C80486CC7A007CD1D0 /* glibmm.framework */;
-			productType = "com.apple.product-type.framework";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		0867D690FE84028FC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "glibmm" */;
-			compatibilityVersion = "Xcode 3.0";
-			hasScannedForEncodings = 1;
-			mainGroup = 0867D691FE84028FC02AAC07 /* glibmm */;
-			productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
-			projectDirPath = "";
-			projectRoot = "";
-			shouldCheckCompatibility = 1;
-			targets = (
-				8D07F2BC0486CC7A007CD1D0 /* glibmm */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXResourcesBuildPhase section */
-		8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
-			isa = PBXResourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				8D07F2C00486CC7A007CD1D0 /* InfoPlist.strings in Resources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXResourcesBuildPhase section */
-
-/* Begin PBXRezBuildPhase section */
-		8D07F2C50486CC7A007CD1D0 /* Rez */ = {
-			isa = PBXRezBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXRezBuildPhase section */
-
-/* Begin PBXSourcesBuildPhase section */
-		8D07F2C10486CC7A007CD1D0 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				69305DF90B89599B00551B5A /* class.cc in Sources */,
-				69305DFC0B89599B00551B5A /* containers.cc in Sources */,
-				69305DFE0B89599B00551B5A /* convert.cc in Sources */,
-				69305E000B89599B00551B5A /* date.cc in Sources */,
-				69305E020B89599B00551B5A /* debug.cc in Sources */,
-				69305E040B89599B00551B5A /* dispatcher.cc in Sources */,
-				69305E060B89599B00551B5A /* error.cc in Sources */,
-				69305E080B89599B00551B5A /* exception.cc in Sources */,
-				69305E0A0B89599B00551B5A /* exceptionhandler.cc in Sources */,
-				69305E0C0B89599B00551B5A /* fileutils.cc in Sources */,
-				69305E100B89599B00551B5A /* init.cc in Sources */,
-				69305E120B89599B00551B5A /* interface.cc in Sources */,
-				69305E140B89599B00551B5A /* iochannel.cc in Sources */,
-				69305E170B89599B00551B5A /* main.cc in Sources */,
-				69305E1A0B89599B00551B5A /* markup.cc in Sources */,
-				69305E1C0B89599B00551B5A /* miscutils.cc in Sources */,
-				69305E1E0B89599B00551B5A /* module.cc in Sources */,
-				69305E200B89599B00551B5A /* object.cc in Sources */,
-				69305E220B89599B00551B5A /* objectbase.cc in Sources */,
-				69305E240B89599B00551B5A /* optioncontext.cc in Sources */,
-				69305E260B89599B00551B5A /* optionentry.cc in Sources */,
-				69305E280B89599B00551B5A /* optiongroup.cc in Sources */,
-				69305E2A0B89599B00551B5A /* pattern.cc in Sources */,
-				69305E3B0B89599B00551B5A /* property.cc in Sources */,
-				69305E3D0B89599B00551B5A /* propertyproxy.cc in Sources */,
-				69305E3F0B89599B00551B5A /* propertyproxy_base.cc in Sources */,
-				69305E410B89599B00551B5A /* quark.cc in Sources */,
-				69305E430B89599B00551B5A /* random.cc in Sources */,
-				69305E470B89599B00551B5A /* shell.cc in Sources */,
-				69305E490B89599B00551B5A /* signalproxy.cc in Sources */,
-				69305E4B0B89599B00551B5A /* signalproxy_connectionnode.cc in Sources */,
-				69305E4E0B89599B00551B5A /* spawn.cc in Sources */,
-				69305E500B89599B00551B5A /* streamiochannel.cc in Sources */,
-				69305E520B89599B00551B5A /* stringutils.cc in Sources */,
-				69305E540B89599B00551B5A /* thread.cc in Sources */,
-				69305E560B89599B00551B5A /* threadpool.cc in Sources */,
-				69305E580B89599B00551B5A /* timer.cc in Sources */,
-				69305E5A0B89599B00551B5A /* timeval.cc in Sources */,
-				69305E5C0B89599B00551B5A /* unicode.cc in Sources */,
-				69305E5E0B89599B00551B5A /* ustring.cc in Sources */,
-				69305E600B89599B00551B5A /* utility.cc in Sources */,
-				69305E620B89599B00551B5A /* value.cc in Sources */,
-				69305E640B89599B00551B5A /* value_basictypes.cc in Sources */,
-				69305E660B89599B00551B5A /* value_custom.cc in Sources */,
-				69305E680B89599B00551B5A /* wrap.cc in Sources */,
-				69305E6A0B89599B00551B5A /* wrap_init.cc in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin PBXVariantGroup section */
-		089C1666FE841158C02AAC07 /* InfoPlist.strings */ = {
-			isa = PBXVariantGroup;
-			children = (
-				089C1667FE841158C02AAC07 /* English */,
-			);
-			name = InfoPlist.strings;
-			sourceTree = "<group>";
-		};
-/* End PBXVariantGroup section */
-
-/* Begin XCBuildConfiguration section */
-		4FADC24308B4156D00ABE55E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3)",
-				);
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../../../Library/Frameworks\"";
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2 = "\"$(SRCROOT)/../../../../../Library/Frameworks\"";
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3 = "\"$(SRCROOT)/../../../../../Library/Frameworks\"";
-				FRAMEWORK_VERSION = A;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_FIX_AND_CONTINUE = YES;
-				GCC_INPUT_FILETYPE = sourcecode.cpp.cpp;
-				GCC_MODEL_TUNING = G5;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = glibmm_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Library/Frameworks";
-				LIBRARY_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
-				);
-				LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(LOCAL_LIBRARY_DIR)/Frameworks/GLib.framework/Versions/2.12.3/Libraries\"";
-				LIBRARY_STYLE = DYNAMIC;
-				MACH_O_TYPE = mh_dylib;
-				PRODUCT_NAME = glibmm;
-				WRAPPER_EXTENSION = framework;
-				ZERO_LINK = YES;
-			};
-			name = Debug;
-		};
-		4FADC24408B4156D00ABE55E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					ppc,
-					i386,
-				);
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				DYLIB_COMPATIBILITY_VERSION = 1;
-				DYLIB_CURRENT_VERSION = 1;
-				FRAMEWORK_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2)",
-					"$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3)",
-				);
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../../../Library/Frameworks\"";
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2 = "\"$(SRCROOT)/../../../../../Library/Frameworks\"";
-				FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3 = "\"$(SRCROOT)/../../../../../Library/Frameworks\"";
-				FRAMEWORK_VERSION = A;
-				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
-				GCC_MODEL_TUNING = G5;
-				GCC_PRECOMPILE_PREFIX_HEADER = YES;
-				GCC_PREFIX_HEADER = glibmm_Prefix.pch;
-				INFOPLIST_FILE = Info.plist;
-				INSTALL_PATH = "$(HOME)/Library/Frameworks";
-				LIBRARY_SEARCH_PATHS = (
-					"$(inherited)",
-					"$(LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
-				);
-				LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(LOCAL_LIBRARY_DIR)/Frameworks/GLib.framework/Versions/2.12.3/Libraries\"";
-				LIBRARY_STYLE = DYNAMIC;
-				MACH_O_TYPE = mh_dylib;
-				PRODUCT_NAME = glibmm;
-				WRAPPER_EXTENSION = framework;
-			};
-			name = Release;
-		};
-		4FADC24708B4156D00ABE55E /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				GCC_PREPROCESSOR_DEFINITIONS = GLIBMM_DISABLE_DEPRECATED;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = (
-					"/usr/local/lib/sigc++-2.0/include",
-					"/usr/local/include/sigc++-2.0",
-					/Users/taybin/Library/Frameworks/GLib.framework/Headers,
-					"/Users/taybin/projects/2.1-staging/libs/glibmm2",
-				);
-				LIBRARY_SEARCH_PATHS = /usr/local/lib;
-				PREBINDING = NO;
-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
-			};
-			name = Debug;
-		};
-		4FADC24808B4156D00ABE55E /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ARCHS = (
-					i386,
-					ppc,
-				);
-				GCC_INPUT_FILETYPE = sourcecode.cpp.cpp;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					LIBSIGC_DISABLE_DEPRECATED,
-					GLIBMM_DISABLE_DEPRECATED,
-				);
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				HEADER_SEARCH_PATHS = (
-					/Library/Frameworks/sigc.framework/Headers,
-					/Library/Frameworks/GLib.framework/Headers,
-					"/Users/taybin/projects/2.1-staging/libs/glibmm2",
-				);
-				PREBINDING = NO;
-				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "glibmm" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4FADC24308B4156D00ABE55E /* Debug */,
-				4FADC24408B4156D00ABE55E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "glibmm" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				4FADC24708B4156D00ABE55E /* Debug */,
-				4FADC24808B4156D00ABE55E /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
-}
diff --git a/libs/glibmm2/macosx/glibmm_Prefix.pch b/libs/glibmm2/macosx/glibmm_Prefix.pch
deleted file mode 100644
index c5bd3b3ca9..0000000000
--- a/libs/glibmm2/macosx/glibmm_Prefix.pch
+++ /dev/null
@@ -1,3 +0,0 @@
-//
-// Prefix header for all source files of the 'glibmm' target in the 'glibmm' project.
-//
diff --git a/libs/glibmm2/scripts/.cvsignore b/libs/glibmm2/scripts/.cvsignore
new file mode 100644
index 0000000000..f480274b19
--- /dev/null
+++ b/libs/glibmm2/scripts/.cvsignore
@@ -0,0 +1,5 @@
+config.guess
+config.sub
+install-sh
+ltmain.sh
+missing
diff --git a/libs/glibmm2/scripts/macros.m4 b/libs/glibmm2/scripts/macros.m4
index 44a9c4de05..dc125a3c9c 100644
--- a/libs/glibmm2/scripts/macros.m4
+++ b/libs/glibmm2/scripts/macros.m4
@@ -29,7 +29,7 @@ AC_DEFUN([AL_PROG_GNU_MAKE],[
 dnl 
 dnl Check for GNU make (stolen from gtk+/configure.in)
 AC_MSG_CHECKING(whether make is GNU Make)
-if ${MAKE-make} --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
+if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
         AC_MSG_RESULT(yes)
 else
         AC_MSG_RESULT(no)
diff --git a/libs/glibmm2/scripts/reduced.m4 b/libs/glibmm2/scripts/reduced.m4
deleted file mode 100644
index 9411a57824..0000000000
--- a/libs/glibmm2/scripts/reduced.m4
+++ /dev/null
@@ -1,106 +0,0 @@
-## GLIBMM_ARG_ENABLE_API_PROPERTIES()
-##
-## Provide the --enable-api-properties configure argument, enabled
-## by default.
-##
-AC_DEFUN([GLIBMM_ARG_ENABLE_API_PROPERTIES],
-[
-  AC_ARG_ENABLE([api-properties],
-      [  --enable-api-properties  Build properties API.
-                              [[default=yes]]],
-      [glibmm_enable_api_properties="$enableval"],
-      [glibmm_enable_api_properties='yes'])
-
-  if test "x$glibmm_enable_api_properties" = "xyes"; then
-  {
-    AC_DEFINE([GLIBMM_PROPERTIES_ENABLED],[1], [Defined when the --enable-api-properties configure argument was given])
-  }
-  fi
-])
-
-## GLIBMM_ARG_ENABLE_API_VFUNCS()
-##
-## Provide the --enable-api-vfuncs configure argument, enabled
-## by default.
-##
-AC_DEFUN([GLIBMM_ARG_ENABLE_API_VFUNCS],
-[
-  AC_ARG_ENABLE([api-vfuncs],
-      [  --enable-api-vfuncs  Build vfuncs API.
-                              [[default=yes]]],
-      [glibmm_enable_api_vfuncs="$enableval"],
-      [glibmm_enable_api_vfuncs='yes'])
-
-  if test "x$glibmm_enable_api_vfuncs" = "xyes"; then
-  {
-    AC_DEFINE([GLIBMM_VFUNCS_ENABLED],[1], [Defined when the --enable-api-vfuncs configure argument was given])
-  }
-  fi
-])
-
-## GLIBMM_ARG_ENABLE_API_EXCEPTIONS()
-##
-## Provide the --enable-api-exceptions configure argument, enabled
-## by default.
-##
-AC_DEFUN([GLIBMM_ARG_ENABLE_API_EXCEPTIONS],
-[
-  AC_ARG_ENABLE([api-exceptions],
-      [  --enable-api-exceptions  Build exceptions API.
-                              [[default=yes]]],
-      [glibmm_enable_api_exceptions="$enableval"],
-      [glibmm_enable_api_exceptions='yes'])
-
-  if test "x$glibmm_enable_api_exceptions" = "xyes"; then
-  {
-    AC_DEFINE([GLIBMM_EXCEPTIONS_ENABLED],[1], [Defined when the --enable-api-exceptions configure argument was given])
-  }
-  fi
-])
-
-## GLIBMM_ARG_ENABLE_API_DEPRECATED()
-##
-## Provide the --enable-deprecated-api configure argument, enabled
-## by default.
-##
-AC_DEFUN([GLIBMM_ARG_ENABLE_API_DEPRECATED],
-[
-  AC_ARG_ENABLE(deprecated-api, 
-      [  --enable-deprecated-api  Include (build) deprecated API in the libraries.
-                              [[default=yes]]],
-      [glibmm_enable_api_deprecated="$enableval"],
-      [glibmm_enable_api_deprecated='yes'])
-
-  if test "x$glibmm_enable_api_deprecated" = "xyes"; then
-  {
-    AC_MSG_WARN([Deprecated API will be built, for backwards-compatibility.])
-  }
-  else
-  {
-    AC_MSG_WARN([Deprecated API will not be built, breaking backwards-compatibility. Do not use this build for distribution packages.])
-    DISABLE_DEPRECATED_API_CFLAGS="-DGLIBMM_DISABLE_DEPRECATED"
-    AC_SUBST(DISABLE_DEPRECATED_API_CFLAGS)
-  }
-  fi
-])
-
-
-## GLIBMM_ARG_ENABLE_API_DEFAULT_SIGNAL_HANDLERS()
-##
-## Provide the --enable-api-default-signal-handlers configure argument, enabled
-## by default.
-##
-AC_DEFUN([GLIBMM_ARG_ENABLE_API_DEFAULT_SIGNAL_HANDLERS],
-[
-  AC_ARG_ENABLE([api-default-signal-handlers],
-      [  --enable-api-default-signal-handlers  Build default signal handlers API.
-                              [[default=yes]]],
-      [glibmm_enable_api_default_signal_handlers="$enableval"],
-      [glibmm_enable_api_default_signal_handlers='yes'])
-
-  if test "x$glibmm_enable_api_default_signal_handlers" = "xyes"; then
-  {
-    AC_DEFINE([GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED],[1], [Defined when the --enable-api-default-signal-handlers configure argument was given])
-  }
-  fi
-])
diff --git a/libs/glibmm2/scripts/sun.m4 b/libs/glibmm2/scripts/sun.m4
deleted file mode 100644
index 6b8950f798..0000000000
--- a/libs/glibmm2/scripts/sun.m4
+++ /dev/null
@@ -1,15 +0,0 @@
-AC_DEFUN([GLIBMM_PROG_CXX_SUN],
-  [AC_CACHE_CHECK(whether we are using SUN CC compiler, ac_cv_prog_sun_cxx,
-    [if AC_TRY_COMMAND(${CXX-g++} -V 2>&1) | egrep "Sun WorkShop" >/dev/null 2>&1; then
-      ac_cv_prog_sun_cxx=yes
-    else
-      ac_cv_prog_sun_cxx=no
-    fi]
-   )]
-
-   if test "x${ac_cv_prog_sun_cxx}" = "xyes"; then
-   {
-     AC_DEFINE([GLIBMM_COMPILER_SUN_FORTE],[1], [Defined when the SUN Forte C++ compiler is being used.])
-   }
-   fi
-)
diff --git a/libs/gtkmm2/ChangeLog b/libs/gtkmm2/ChangeLog
index 526ea1c06d..9966e67673 100644
--- a/libs/gtkmm2/ChangeLog
+++ b/libs/gtkmm2/ChangeLog
@@ -1,2706 +1,3 @@
-2.10.7:
-
-2007-01-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/main.ccg: Destructor: Call the cleanup functions, instead of calling 
-	init again. This seems to be a copy/paste error from April 2003. 
-	Bug #383340 from Christopher Raine.
-
-2007-01-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/index.html: Add a Google search, restricted to the gtkmm documentation.
-
-2007-01-12  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* gtk/src/printoperation.ccg: Specify a template specialization for
-	Glib::unwrap() to avoid ambiguities detected and reported as errors
-	in Sun Workshop on OpenSolaris. Bug #395572 from Tim Mooney.
-
-2006-12-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: libglade with derived widgets: Add more explanation 
-	about the BaseObjectType typedef.
-	Patch from Martin Nordholts in bug #387708.
-
-2006-12-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/sizegroup.hg: Added class documentation.
-
-2.10.6:
-
-2006-11-28  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/drawable.hg: create_cairo_context(): Specify true to 
-	the Cairo::Context constructor because we have a starting reference. 
-	This should prevent a leak an extra reference.
-	* gtk/src/printcontext.hg: get_cairo_context():
-	* gtk/src/printjob.hg: get_surface(): Pass false to the Cairo constructor, 
-	because we do not receive a reference, and do not use refreturn(). Previously 
-	we did two references were one was needed.
-
-2.10.5:
-
-2006-11-24  Johannes Schmid <johannes.schmid@openismus.com>
-
-	* gtk/src/uimanager.ccg:
-	Fixed a crasher in error handling when exceptions are disabled 
-
-2006-11-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: UIManager: Added notes about which 
-	parts are human-readable and which parts are just IDs, with a 
-	suggestion about what part to mark for translation.
-
-2006-11-23  Nate Nielsen  <nielsen@memberwebs.com>
-
-	* gtk/src/style.ccg:
-	* gtk/src/style.hg: lookup_icon_set(): Hand-code this method, 
-	so we can copy the result of gtk_style_lookup_icon_set(), 
-	because it does not give us a new instance.
-	Bug #374094
-
-2006-11-22  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* configure.in: Do not pkgconfig check gtk+-unix-print-2.0 on
-	win32, as gtk+-unix-print-2.0.pc is not always included in GTK+
-	installers and/or binary archives (like in Tor's binaries).
-	Bug #371882 from Alexis Wilke.
-
-2.10.4:
-
-2006-11-21  Rémi Cardona  <remi2402@free.fr>
-
-	* configure.in:
-	* gtk/gtkmm-2.4.pc.in: Define a GTKMM_PC_ATKMM_DEP conditional and 
-	use it so that atkmm is only required when it is built, and not 
-	when disbaled via --enable-api-atkmm=no.
-	Bug #366930 from John N. Laliberte.
-
-2006-11-14  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in:
-	* gtk/gtkmmconfig.h.in:
-	* scripts/reduced.m4: Added --enable-api-maemo-extensions 
-	configure option, default to false, defining the 
-	GTKMM_MAEMO_EXTENSIONS_ENABLED macro.
-	* gtk/src/textbuffer.hg:
-	* gtk/src/textbuffer.ccg: Put the Maemo-specific API in 
-	ifdefs, using the optional _WRAP_METHOD() parameter.
-
-2006-11-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Optional API appendix: Use the 
-	<function> tag.
-
-2006-11-14  Daniel Elstner  <daniel.kitta@gmail.com>
-
-	* autogen.sh: Wholly replace this script with a critter from one
-	of my personal projects, with slight modifications.  This one does
-	some sophisticated stuff like probing version numbers of available
-	automake and aclocal executables, in order to choose the right one
-	accordingly.  All this is necessary to make the build system work
-	robustly in custom environments such as Maemo where automake-1.9
-	doesn't come preinstalled.
-	While we're at it, kill some old cruft such as the check for GNU
-	make.  This test was kind of pointless as the $MAKE variable was
-	never exported.  Also get rid of the --enable-warnings=hardcore
-	magic; this just doesn't belong here and could cause unnecessary
-	trouble to non-developers.
-
-2006-11-13  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/reference/Doxyfile.in: Add missing PREDEFINES so that we build 
-	documentation only for the normal API.
-
-2006-11-12  Ralf Stephan    <ralf@ark.in-berlin.de>
-	
-	* gdk/src/drawable.hg: Add comment paragraph about using cairo.
-
-2006-11-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in:
-	* tests/Makefile.am:
-	* tests/main.cc: Add new test, with commented-out test for an alternative 
-	API that I will add to glibmm.
-
-2.10.3:
-
-2006-11-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/adjustment.ccg:
-	* gtk/src/adjustment.hg: Hand-code the constructor so that we can provide 
-	the g_object_new() properties in a non-standard order, so that the value 
-	is not ignored. This is what gtk_adjustment_new() does too.
-	Bug #369335 from Daniel Holbach, via Vincent Levesque in the Ubuntu 
-	Launchpad bug-tracker.
-
-2006-10-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Added an appendix describing the optional 
-	API for reduced resources devices, and the corresponding ifdefable macros.
-
-2006-10-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/gdk_docs_override.xml: Provide a corrected version of the 
-	Drawable::get_image() method, to avoid mentioning a function that 
-	does not exist in gtkmm. Bug #358268 from Evgeny Rippi.  
-
-2006-10-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_docs_override.xml: Correct the documentation for 
-	gtk_container_remove() and gtk_widget_add_mnemonic_label() to 
-	avoid mention of non-existant destroy signal and destroy() method.
-	Thanks to Nickolai Dobrynin for pointing this out.
-
-2006-10-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/index.html: Correct the links to the Memory Management 
-	and libglademm chapters.
-
-2006-10-02  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/gtkmm/listviewtext.cc: get_column_title(): 
-	Use "" instead of Glib::ustring() in 
-	g_return_val_if_fail() to fix an odd build problem with 
-	gcc 3.3.6. Bug #352226. (Thomas Zajic)
-
-2006-10-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* Makefile.am:
-	* docs/FAQ/Makefile.am:
-	* docs/Makefile.am:
-	* docs/Makefile_web.am_fragment:
-	* docs/images/Makefile.am:
-	* docs/reference/Makefile.am:
-	* docs/tutorial/Makefile.am:
-	* examples/Makefile.am: Upload to the new hoster instead of to sourceforge.
-	Abstracted the host and path names into docs/Makefile_web.am_fragment to 
-	avoid duplication.
-
-2.10.2:
-
-2006-09-21  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/book/socket/Makefile.am: remove source file dependency on a
-	non-existent file.  This was part of an earlier example, but I simplified
-	the example and removed this file so that it would be easier to understand,
-	but forgot to remove it from the Makefile.am
-
-2006-09-19  Johannes Schmid <jhs@gnome.org>
-
-	* scripts/reduced.m4: Added GTKMM_ARG_ENABLE_API_ATKMM() to 
-	add the --enable-api-atkmm configure option.
-	* configure.in: Use GTKMM_ARG_ENABLE_API_ATKMM, and optionally 
-	use the atkmm subdirectory (and its children).
-	* gtk/gtkmmconfig.h.in: undef GTKMM_ATKMM_ENABLED so that 
-	it will be defined (or not) in gtkmmconfig.h.
-	* Makefile.am: Optinally build in the atkmm directory..
-	* demos/Makefile.am:
-	* demos/gtk-demo/Makefile.am:
-	* examples/Makefile.am_fragment:
-	* tests/Makefile.am_fragment: 
-	* gtk/gtkmm/Makefile.am: Make linking and including of 
-	atkmm optional.
-	* gtk/src/main.ccg: Only call Atk::wrap_init() if atkmm is enabled.
-	* gtk/src/widget.hg: Only derive from (and implement) 
-	Atk::Implementor if atkmm is enabled.
-	get_accessible():
-	* gtk/src/combobox.hg: get_popup_accessible():
-	Use the extra ifdef GTKMM_ATKMM_ENABLED option to put ifdefs around this 
-	API, so that it will not be built if we do not have atkmm.
-	Note that this needs the latest glibmm.
-
-2006-09-19  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in, docs/tutorial/figures/Makefile.am,
-	docs/tutorial/figures/socket-fail.png, docs/tutorial/figures/socket.png,
-	docs/tutorial/gtkmm-tut.xml, examples/book/Makefile.am,
-	examples/book/socket/.cvsignore, examples/book/socket/Makefile.am,
-	examples/book/socket/plug.cc, examples/book/socket/socket.cc: added new
-	chapter to the tutorial on Gtk::Plug and Gtk::Socket, including a simple
-	example program and a couple of screenshots.
-
-2006-08-23  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in: re-enabled --disable-demos configure option.  It was
-	disabled due to a bit of stupidity on my part.
-
-2.10.1:
-
-2006-08-21  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* NEWS: update for 2.10.1 release
-
-2006-08-21  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* gtk/src/button.hg: fix a typo in the new API for
-	Gtk::Button::get_image_position() (was set_image_position()).  Fixes bug
-	number 352088.
-	* configure.in: bumped revision to 2.10.1 for new release, disabled
-	configuration switch for disabling demos because it was breaking 'make
-	distcheck' and I couldn't get it figured out in time for a release.  For now
-	it will just always build the demos.
-
-2006-08-21  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* MSVC_Net2003/*.vcproj, MSVC_Net2003/gtkmm.sln: Updated for
-	gtkmm-2.10.
-	* MSVC_Net2003/examples/printing/*: Added printing example.
-	* gtk/src/Makefile_list_of_hg.am_fragment: Moved
-	pagesetupunixdialog.hg, printer.hg, printjob.hg and
-	printunixdialog.hg to files_posix_hg.
-	* gtk/src/pagesetupunixdialog.hg, gtk/src/printer.hg,
-	gtk/src/printjob.hg, gtk/src/printunixdialog.hg: Tag classes with
-	_GTKMMPROC_WIN32_NO_WRAP as they are not supported on win32.
-	* configure.in: Added MSVC project file for printing example to
-	AC_CONFIG_FILES list. Added pangocairo to the list of packages
-	checked by PKG_CHECK_MODULES (required for building DLLs on win32).
-
-2.10.0:
-
-2006-08-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Correct the needed cairomm version.
-	* gdk/gdkmm/general.h: Add documentation for Cairo::rectangle() and 
-	Cairo::region().
-	* gtk/src/scrolledwindow.hg: get_[v|h]scrollbar(): Do not use refreturn, 
-	because they are widgets, not just refcountable objects.
-
-2006-08-17  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Fix tutorial to include code for the simple
-	printing example
-
-2006-08-16  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* examples/book/printing/advanced/examplewindow.cc:
-	* examples/book/printing/advanced/examplewindow.h:
-	Bind pointers to RefPtrs of PrintFormOperation. This solves the issue
-	of PFOs having unnecessarily increased refcount and makes them deleted
-	as soon as they're completed.
-	Removed on_printoperation_preview_done() as the settings stay in
-	the print dialog anyway.
-	* examples/book/printing/advanced/main.cc: Deleted a commented line.
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/previewdialog.h:
-	Explained the use of m_SpinAdjustment.
-	* examples/book/printing/advanced/printformoperation.cc:
-	* examples/book/printing/advanced/printformoperation.h:
-	Uncommented the code for custom tab in print dialog. Within
-	on_create_custom_widget(), use Gtk::manage() for the main vbox too.
-	Removed signal_preview_done.
-
-	Also removed the g_debugs and reformatted some lines in all files.
-
-2006-08-15  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Require the latest cairomm (0.7.0), which we 
-	apparently need.
-
-2006-08-11  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* gtk/src/pagesetup.hg
-	* gtk/src/pagesetupunixdialog.hg
-	* gtk/src/printcontext.hg:
-	* gtk/src/printer.hg:
-	* gtk/src/printoperation.hg:
-	* gtk/src/printunixdialog.hg:
-	* gtk/src/recentchooser.hg:
-	* gtk/src/recentchooserdialog.hg:
-	* gtk/src/recentchoosermenu.hg:
-	* gtk/src/recentchooserwidget.hg:
-	* gtk/src/recentfilter.hg:
-	* gtk/src/recentinfo.hg:
-	* gtk/src/recentmanager.hg: Added or updated from C docs.
-	* gtk/src/printoperationpreview.hg: Removed a TODO about ready and
-	got_page_size signals.
-
-2006-08-11  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* docs/tutorial/figures/Makefile.am:
-	* docs/tutorial/figures/printing.png: Added a screenshot of the main
-	window of the printing example(s).
-	* docs/tutorial/gtkmm-tut.xml: Minor changes to the printing chapter:
-	fixed end_print() explanation, mentioning of the advanced example and
-	the title of the example figure.
-
-2.9.10:
-
-2006-08-05  Johannes Schmid  <jhs@cvs.gnome.org>
-
-	* docs/tutorial/gtkmm-tut.xml:
-	Utility is called enum.pl not enums.pl (#350028)
-
-2006-08-03  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/previewdialog.h:
-	Store the print context as a member variable instead of using sigc::bind 
-	to use it in on_drawing_area_realized(). Null the print context and preview 
-	refptrs when we call end_preview(), because we have stopped using them, 
-	and maybe we should not be keeping their objects alive. 
-
-2006-08-03  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/previewdialog.h:
-	* examples/book/printing/advanced/printformoperation.cc:
-	Don't pass page_count as a ctor parameter but access it directly via
-	m_pOperation when needed. It's also incorrect the first way because
-	it has not yet been determined at the point of PreviewDialog's
-	construction. Added an Adjustment to use it with the spin button
-	in PreviewDialog so that spinning within multiple pages actually works.
-
-2006-08-03  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* examples/book/printing/advanced/previewdialog.cc:
-	Added forgotten call to hide() in on_close_clicked().
-
-2006-08-03  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/previewdialog.h:
-	Added on_hide(), so that we call PrintOperationPreview's end_preview()
-	on window manager's close action too.
-
-2006-08-02  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/printing/advanced/previewdialog.cc: Constructor:
-	Improve the packing of the widgets.
-	on_popreview_got_page_size(): Add a comment to explain.
-
-2006-08-02  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/printing/advanced/previewdialog.cc:
-	Constructor: Initialize m_DpiX and m_DpiY, as noticed by valgrind. 
-	Connect to signals here instead of later, so we do not risk connecting 
-	more than once.
-	on_drawing_area_realized(): Check gdk_window is not null before using it.
-	on_popreview_got_page_size(): Check that drawing_area is realized before 
-	trying to get its allocation. Possibly not necessary. Check the pango 
-	layout is not null before using it.
-	* examples/book/printing/advanced/printformoperation.cc: on_draw_page(): 
-	Check that the print context and pango layout are not null before using 
-	them.
-	* examples/book/printing/advanced/printformoperation.h: Connect to the 
-	hide signal of the dialog instead of delete_event().
-
-2006-08-02  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/previewdialog.h: Rename the signal 
-	handlers so it is is bit clearer. Use show_all_children() instead of 
-	show_all() so that the caller can decided when to show the window.
-	* examples/book/printing/advanced/printformoperation.cc: Use show(), 
-	and set the dialog pointer to 0 after deleting it.
-
-2006-08-02  Armin Burgmeier  <armin@arbur.net>
-
-	* gtk/src/fontbutton.hg: Renamed constructor argument to font_name
-	for gmmproc to produce the correct property name.
-
-
-2006-08-02  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/previewdialog.h:
-	* examples/book/printing/advanced/printformoperation.cc:
-	* examples/book/printing/advanced/printformoperation.h:
-	Further efforts to fix #347857. See comment #14.
-	* gtk/src/pagesetup.hg:
-	Removed some commented conversions for PaperSize which haven't been
-	used ever since convert_gtk.m4 contains the necessary.
-	* gtk/src/printoperationpreview.hg:
-	Fixed the conversion for PrintContext which takes a reference and fixes
-	some of the problems in the bug. Uncommented ready and got_page_size
-	signals.
-	* tools/m4/convert_gtk.m4:
-	Made both conversions for PaperSize (C to Cpp) take a reference.
-	Removed two unnecessary conversions for PrintContext.
-
-2006-08-01  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/figures/Makefile.am:
-	* docs/tutorial/figures/recentchooserdialog.png:
-	* docs/tutorial/gtkmm-tut.xml: added a screenshot of the RecentChooserDialog
-	and a bit of additional explanation to the example
-
-2006-08-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/recentchooser.ccg:
-	* gtk/src/recentchooser.hg:
-	* gtk/src/recentinfo.ccg:
-	* gtk/src/recentinfo.hg:
-	* gtk/src/recentmanager.ccg:
-	* gtk/src/recentmanager.hg: Move RecentInfoTraits into recentinfo.hg, and 
-	use it for RecentManager::get_items() as well as the existing 
-	RecentChooser::get_items().
-
-2006-07-30  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/recentchooser.ccg:
-	* gtk/src/recentchooser.hg:
-	* gtk/src/recentinfo.hg:
-	* gtk/src/recentmanager.hg: Use RecentInfo via RefPtr always.
-	* tools/m4/convert_gtk.m4:
-
-2006-07-27  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/index.html: Linked to the wiki page.
-
-20c06-07-26  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/recentinfo.hg: Use _CLASS_OPAQUE_REFCOUNTED instead of 
-	_CLASS_OPAQUE_COPYABLE(), because this struct has ref/unref instead 
-	of copy/free. This causes the reference() and unreference() methods 
-	to generated.
-	* examples/book/printing/advanced/printformoperation.cc: 
-	Wrapping C libraries section: Correct the _CLASS_OPAQUE_COPYABLE 
-	section and mention _CLASS_OPAQUE_REFCOUNTED.
-
-2006-07-25  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/book/recent_files/examplewindow.cc:
-	* examples/book/recent_files/examplewindow.h: Fix recent files example so
-	that it actually pops up a dialog when you select the recent files menu
-	item.  Also added _mnemonics to menu items for easy keyboard navigation :)
-
-2006-07-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/printing/advanced/printformoperation.cc:
-	* examples/book/printing/advanced/printformoperation.h: Uncomment out 
-	the on_preview() override again, and add an if that shows that m_refLayout is 
-	null, because on on_begin_print() has never been called.
-
-2006-07-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/printing/advanced/examplewindow.cc:
-	* examples/book/printing/advanced/printformoperation.cc:
-	* examples/book/printing/advanced/printformoperation.h:
-	* examples/book/printing/simple/examplewindow.cc: Made the two examples more 
-	like each other, so that it is more obvious what is causing the crash, 
-	though I commented out the crashing override, with a comment.
-
-
-2006-07-24  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Added preliminary chapter on using the new
-	recent files API (RecentManager, RecentChooser, etc).  I really think that
-	the recent_files example could use some simplification, but I haven't
-	tackled that at all yet.  I'm going to leave out any UIManager / Recent
-	files integration for now since it seems like it will be a big manual hack
-	until GtkRecentAction gets introduced in GTK+ 2.12
-	* examples/book/recent_files/Makefile.am: renamed the executable name that
-	seemed to be a copy-paste error and was rather confusing
-
-2.9.9:
-
-2006-07-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Depend on glibmm 2.11.3 so that the new defines are available 
-	for the (default) --enable-api-default-signal-handlers=yes case.
-	* gtk/src/printcontext.hg:
-	* gtk/src/printer.hg:
-	* gtk/src/printjob.hg:
-	* gtk/src/printoperation.hg:
-	* gtk/src/printoperationpreview.hg:
-	* gtk/src/printsettings.hg:
-	* gtk/src/printunixdialog.hg: Use our special newin2p10 doxygen keyword.
-
-2006-07-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/widget.hg: Moved the new composited_changed signal to the bottom 
-	because that is where I like them, and because adding virtual methods in 
-	the middle of other virtual methods changes the offsets of existing 
-	virtual methods, breaking ABI. Also, used no_default_signal, to avoid 
-	even having a virtual method, which would increase the object size, breaking 
-	ABI. I have made this mistake before. This should fix bug #348241. 
-
-2006-07-23  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* gtk/src/recentmanager.hg: change API to use overloaded functions instead
-	of different function names.  RecentManager::add_full() was changed to
-	RecentManager::add_item() per discussion on mailing list.
-
-2006-07-20  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/printoperation.hg: Added the forgotten refreturn for
-	get_print_settings(), which fixes a part of #347857.
-
-2006-07-20  Marko Anastasov <marko@marko.anastasov.name>
-
-	* examples/book/printing/advanced/examplewindow.h:
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/printformoperation.cc:
-	* examples/book/printing/simple/printformoperation.cc:
-	Replaced calls to pango_cairo_* functions with their wrappers;
-	removed some unnecessary comments.
-
-2006-07-20  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/widget.hg: Fixed a typo for input_shape_combine_mask(),
-	to wrap the right GTK method.
-
-2006-07-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/container.ccg:
- 	* gtk/src/entrycompletion.ccg:
-	* gtk/src/entrycompletion.hg:
-	* gtk/src/widget.ccg: Put custom default signal handlers in #ifdefs so that 
-	gtkmm builds when --enable-api-default-signal-handlers was used with glibmm.
-
-2006-07-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/spinbutton.hg: Wrap the new wrapped signal, without 
-	a default handler because that would break ABI.
-
-2006-07-18  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/*: reverted changes to includes in example programs
-
-2.9.8:
-
-2006-07-18  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/textbuffer.ccg:
-	* gtk/src/textbuffer.hg: Wrapped some of the functions from gtktextbufferrichtext.h, 
-	but left some of it commented-out while I discover how it should work, to avoid 
-	creating a bad API that we can not change later.
-
-2006-07-10  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* gtk/src/widget.ccg:
-	* gtk/src/widget.hg: wrapped is_composited(), composited_changed signal,
-	input_shape_combine_mask(), unset_input_shape_combine_mask()
-
-2006-07-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/index.html: Update links, because inserting the printing chapter increased 
-	subsequent chapter numbers. 
-	* docs/tutorial/gtkmm-tut.xml: Wrapping C libraries: Mentioned _WRAP_ENUM().
-	* gtk/src/togglebutton.ccg:
-	* gtk/src/togglebutton.hg: Added a constructor that takes a stock item, like 
-	Button already has.
-
-2006-07-13  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Minor corrections to the language in the 
-	new printing chapter.
-
-2006-07-13  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: gmmproc appendix: Corrected the description of 
-	the _DEFS() macro, and mention not to include C headers in C++ headers.
-
-2006-07-12  Marko Anastasov <marko@marko.anastasov.name>
-
-	* docs/tutorial/gtkmm-tut.xml: Added a chapter about printing.
-
-2006-07-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Added an appendix about wrapping C libraries with 
-	gmmproc, including the various things you need to change when copying an 
-	existing project.
-
-2006-07-10  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/index.html: update to match the style of the new website a bit
-	* docs/tutorial/style.css: change the style of the tutorial slightly to
-	match the website style.  These are just minor tweaks.  Ideally I think they
-	should both get a bit more of an overhaul.
-
-2006-07-09  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* .cvsignore: add a whole bunch of files to .cvsignore
-
-2006-07-09  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/*: Don't include <gtkmm.h> if possible.  Modified all examples to
-	only include the headers that they absolutely need.  Hopefully this speeds
-	up compilation at least slightly and reduces the amount of recompilation
-	needed for examples due to unrelated changes.
-
-2006-07-08  Marko Anastasov <marko@marko.anastasov.name>
-
-	* examples/book/printing/simple/examplewindow.cc:
-	* examples/book/printing/simple/main.cc:
-	* examples/book/printing/simple/printformoperation.cc:
-	Minor code cleanup to fit the tutorial.
-
-2006-07-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/entrycompletion.hg:
-	* gtk/src/iconview.hg:
-	* gtk/src/treeviewcolumn.hg: Added TODOs to mention new bases clases 
-	(interfaces that these GTypes now implement) that we may not add as 
-	base classes without breaking C++ ABI. 
-
-2006-07-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printoperationpreview.hg: Commented-out the signals, with a TODO, 
-	for now because they seem to cause a crash when viewing the preview.
-
-2006-07-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printoperation.hg: Derive from, and implement, PrintOperationPreview, 
-	so that the dynamic_cast in the Glib::wrap() in on_preview() can succeed.
-	* examples/book/printing/advanced/examplewindow.cc:
-	* examples/book/printing/simple/examplewindow.cc: Do not set a window 
-	border width. It looks odd, and it is not normal to have a border around the 
-	menu.
-
-2006-07-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/printing/advanced/Makefile.am:
-	* examples/book/printing/simple/Makefile.am: Rename the executable to 
-	example, to match the other examples.
-
-2006-07-07  Marko Anastasov <marko@marko.anastasov.name>
-
-	* configure.in
-	* examples/book/printing/Makefile.am: Split the printing example into
-	"simple" and "advanced".
-	* examples/book/printing/advanced/:
-	* examples/book/printing/advanced/Makefile.am:
-	* examples/book/printing/advanced/examplewindow.cc:
-	* examples/book/printing/advanced/examplewindow.h:
-	* examples/book/printing/advanced/main.cc:
-	* examples/book/printing/advanced/previewdialog.cc:
-	* examples/book/printing/advanced/previewdialog.h:
-	* examples/book/printing/advanced/printformoperation.cc:
-	* examples/book/printing/advanced/printformoperation.h:
-	Advanced example meant to demonstrate how to extend the print dialog
-	and create a custom preview dialog.
-	* examples/book/printing/simple:
-	* examples/book/printing/simple/Makefile.am:
-	* examples/book/printing/simple/examplewindow.cc:
-	* examples/book/printing/simple/examplewindow.h:
-	* examples/book/printing/simple/main.cc:
-	* examples/book/printing/simple/printformoperation.cc:
-	* examples/book/printing/simple/printformoperation.h:
-	Printing API example showing the essential work, relying on the
-	external viewer program (previewing still needs more work).
-
-2006-07-07  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/pagesetup.hg:
-	* gtk/src/papersize.hg:
-	* gtk/src/printer.hg:
-	* gtk/src/printjob.hg: 
-	* gtk/src/printoperationpreview.hg:
-	* gtk/src/printsettings.hg: Added class documentation, based on the 
-	C documentation.
-	* gtk/src/printoperation.ccg:
-	* gtk/src/printoperation.hg: custom_widget_appl signal: Pass the 
-	widget by pointer, in case the C developers ever decide that it may be null.
-	SlotPrintSetupDone: Pass a _const_ RefPtr.
-	run_page_setup_dialog_async(), run_page_setup_dialog(): Pass _const_ PageSetup and 
-	PrintSettings, because I think the function does not change them.
-	* examples/book/printing/examplewindow.cc:
-	* examples/book/printing/examplewindow.h:
-	* examples/book/printing/previewdialog.cc:
-	* examples/book/printing/previewdialog.h:
-	* examples/book/printing/printformoperation.cc:
-	* examples/book/printing/printformoperation.h: Some renaming and comments and TODOs.
-
-2006-07-07  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Remove the mention of examples/printing, because 
-	it is in examples/book/printing instead.
-
-2006-07-06  Marko Anastasov <marko@marko.anastasov.name>
-
-	* configure.in
-	* examples/book/Makefile.am: Include the printing example.
-	* examples/book/printing/
-	* examples/book/printing/Makefile.am:
-	* examples/book/printing/examplewindow.cc:
-	* examples/book/printing/examplewindow.h:
-	* examples/book/printing/main.cc:
-	* examples/book/printing/previewdialog.cc:
-	* examples/book/printing/previewdialog.h:
-	* examples/book/printing/printformoperation.cc:
-	* examples/book/printing/printformoperation.h: New files -
-	example of the printing API. Previewing is not finished.
-
-2.9.7:
-
-2006-07-05  Marko Anastasov <marko@marko.anastasov.name>
-
-	* demos/gtk-demo/example_change_display.cc:
-	* pango/src/tabarray.ccg: Fix the build by preventing warnings with
-	small workarounds.
-	* gtk/src/gtk_signals.defs: Restored defs for PrintOperationPreview.
-	* gtk/src/printcontext.hg: Removed a TODO for ctor - it's always
-	exposed through PrintOperation's signals.
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_signals.defs: Restored Printer and PrintJob defs.
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_signals.defs: Restored the Print*Unix stuff.
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/scrolledwindow.hg: Reimplemented get_h/vscrollbar() with the 
-	new methods in GTK+.
-	* gtk/src/selectiondata.ccg:
-	* gtk/src/selectiondata.hg: Added targets_include_rich_text().
-	* gtk/src/sizegroup.hg: Added get/set_ignore_hidden().
-	* gtk/src/statusicon.hg: Added size_changed signal.
-	* gtk/src/gtk_signals.defs: Regenerated.
-	* gtk/src/notebook.hg: Added page_reordered, page_removed, and page_added 
-	signals.
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printoperation.hg: Wrap the preview signal, using PrintOperationPreview 
-	via RefPtr, which might be appropriate. The refcounting might need examination.
-
-2006-07-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printoperation.hg: Commented-out the preview signal for now, because 
-	the conversion is bad/wrong, and it is difficult to do, because gmmproc 
-	assumes that we want to deal with the interface via RefPtr.
-
-2006-06-30  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/printoperation.hg: Added a default value of
-	PRINT_OPERATION_ACTION_PRINT_DIALOG to the version of run() without
-	std::auto_ptr<Glib::Error>.
-
-2006-06-25  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: add links to gtkmm_hello and gnomemm_hello
-	programs.  Patch from Gezim Hoxha (fixes #345894)
-
-2006-06-25  Marko Anastasov <marko@marko.anastasov.name>
-
-	* docs/tutorial/gtkmm-tut.xml: Fixed the sentence explaining
-	disconnect() in the Timeouts chapter. #345848 from Gezim Hoxha.
-
-2006-06-24  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/printcontext.hg: Renamed the const function get_cairo()
-	to get_cairo_context(), to match the original.
-
-2006-06-24  Marko Anastasov <marko@marko.anastasov.name>
-
-	* docs/tutorial/gtkmm-tut.xml: Typo correction in the Clipboard
-	chapter by Gezim Hoxha.
-
-2.9.6:
-
-2006-06-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printjob.ccg:
-	* gtk/src/printjob.hg: send_job(): This no longer throws an 
-	exception, because the C function no longer takes a GError*.
-	* gtk/src/statusicon.ccg:
-	* gtk/src/statusicon.hg: get_geometry(): Compilation fixes.
-
-2006-06-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/label.hg: Added get/set_line_wrap_mode() and property.
-	* gtk/src/menushell.hg: Added get/set_take_focus() and property.
-	* gtk/src/printsettings.ccg:
-	* gtk/src/printsettings.hg: Put the standard settings in a member 
-	class as static const Glib::ustrings, initialized in the .cpp file.
-	* gtk/src/statusicon.ccg:
-	* gtk/src/statusicon.hg: Added get_geometry().
-
-2006-06-21  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py.
-	* gtk/src/printer.ccg:
-	* gtk/src/printer.hg: Wrapped get_job_count() which was accidentaly
-	in the ignore list. New function: enumerate_printers().
-
-2006-06-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printunixdialog.ccg: Add the Gtk:: prefix for Label, to 
-	fix the build, and include the label.h header.
-
-2006-06-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printoperation.hg: Include the C header in the private/*.h 
-	file, so that it can use the enum.
-	* gtk/src/printsettings.hg: Remove PRINT_SETTINGS_PRINT_TO_FILE.
-	We really need to make this more like the Stock IDs.
-
-2006-06-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_enums.defs: Updated with enums.pl
-	* gtk/src/messagedialog.hg: Added set_image() and property.
-	* gtk/src/printoperation.hg: Do not include gtkprintoperation.h.
-	preview signal: Pass parent window as pointer, in case it is null.
-	* gtk/src/printoperationpreview.hg: Signals: Do not use 
-	no_default_handler, because this class is new so we do not need to 
-	preserver ABI.
-	* gtk/src/printunixdialog.ccg:
-	* gtk/src/printunixdialog.hg: Added add_custom_tab() overload that 
-	takes a ustring.
-	* gtk/src/printsettings.hg: Remove get/set_print_to_file(), because 
-	the C function was removed from GTK+.
-	* gtk/src/treeview.hg: Correct return type of get_grid_lines().
-	* tools/m4/convert_gtk.m4: Add conversion for TreeViewGridLines enum.
-
-2006-06-20  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py.
-	* gtk/src/gtk_signals.defs: Updated the whole section for
-	PrintOperation.
-	Added defs for PrintOperationPreview: ready and got_page_size.
-	Added accepts_pdf ans accepts_ps properties for Printer.
-	* gtk/src/gtk_vfuncs.defs: Added a section for PrintOperationPreview
-	with render_page, end_preview and is_selected.
-	* gtk/src/printer.hg: New functions (properties likewise):
-	accepts_pdf() and accepts_ps().
-	* gtk/src/printjob.ccg: Include gtktypebuiltins.h.
-	* gtk/src/printjob.hg: New enum: PrintCapabilities.
-	* gtk/src/printoperation.ccg:
-	* gtk/src/printoperation.hg: Added a version of run() without
-	the Window parameter.
-	New signals: done, create_custom_widget, custom_widget_apply,
-	and preview.
-	Renamed properties: number_of_pages and pdf_target. Added n_pages
-	and export_filename instead, and custom_tab_label.
-	* gtk/src/printoperationpreview.ccg:
-	* gtk/src/printoperationpreview.hg: New files.
-	* gtk/gtkmm.h:
-	* gtk/src/Makefile_list_of_hg.am_fragment: Include the new files.
-	* gtk/src/printunixdialog.hg: New functions: add_custom_tab and
-	set_manual_capabilities.
-	* tools/m4/convert_gtk.m4: Added new conversions.
-
-2006-06-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.hg: Added get/set_rubber_banding(), 
-	get/set_grid_lines(), get/set_enable_tree_lines().
-	Added properties for show-expanders, level-indentation, 
-	rubber-banding, enable-grid-lines, and enable-tree-lines.
-
-2.9.5:
-
-2006-06-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.ccg: Provide implementation for 
-	set_search_position_func(). Bug #344787 from 
-	Elijah Newren.
-
-2006-06-19  Elijah Newren  <newren gmail com>
-
-	* autogen.sh: Turn on -Werror for gcc-4.x too.  #345245
-
-2006-06-17  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* gtk/gtkmm/accelmap.cc: add missing initializer (fixes #344788)
-
-2006-06-16  Elijah Newren  <newren gmail com>
-
-	* gtk/src/recentchooser.hg: release_c_type: fix an unused variable
-	warning.  #344786
-
-2006-06-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/notebook.ccg: SignalProxy_WindowCreation_gtk_callback:
-	Comment-out unused source parameter and return a value when an 
-	exception is caught, to prevent compiler warnings. 
-	Bug #344771 from Elijah Newren.
-
-2006-06-13  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* pango/pangomm-1.4.pc.in: add pangocairo dependency (fixes #344802).
-	Thanks to Elijah Newren.
-
-2006-06-13  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/book/treeview/listviewtext/examplewindow.cc:
-	* examples/book/treeview/listviewtext/examplewindow.h: fixed an
-	initialization order error when compiling with -Werror (fixes #344789)
-
-2006-06-13  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/aboutdialog.ccg: set_url_hook(): Pass the slot pointer instead of a 
-	pointer to the slot pointer, so that this works again.
-
-2006-06-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/assistant.hg: Added update_buttons_state().
-	* gtk/src/button.hg: Added get/set_image_position() and property.
-	* gtk/src/clipboard.ccg:
-	* gtk/src/clipboard.hg: Added request_rich_text(), wait_for_rich_text(), 
-	and wait_rich_text_is_available(). 
-	util_convert_atoms_to_strings(): Prevent memory leak of the result of 
-	gdk_atom_name().
-	* gtk/src/entry.hg: Added get/set_inner_border().
-
-2006-06-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/screen.hg: Added get_rgba_visual(), get_rgba_colormap().
-	* pango/src/context.ccg:
-	* pango/src/context.hg: Added get_matrix().
-	* pango/src/renderer.ccg:
-	* pango/src/renderer.hg: Added get_matrix().
-
-2006-06-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/custom/custom_widget/custom_gtkrc:
-	* examples/book/custom/custom_widget/mywidget.cc:
-	* examples/book/custom/custom_widget/mywidget.h: Make the RC file stuff 
-	work - the secret is that the style value is only available when the 
-	widget has been realized. However, this only works at the moment when 
-	hacking glibmm to change the gtkmm_ prefix to Gtkmm_, due to bug #343012.
-	* gtk/src/notebook.ccg: set_window_creation_hook(): Adapt to the changed GTK+ C 
-	API, supplying the destroy notification.
-	* gtk/src/printoperation.hg: Removed set_show_dialog(), set_pdf_target(), 
-	set_track_print_status(), run_async().
-	Added set_export_filename(), set_track_print_status(), 
-	set_show_progress(), set_allow_async(), set_custom_tab_label().
-	This is to match the C API.
-	* pango/src/font.ccg:
-	* pango/src/font.hg: Added describe_with_absolute_size(), get_font_map(). 
-	* pango/src/fontdescription.hg: Added set_absolute_size(), get_size_is_absolute().
-	* pango/src/layout.hg: Added get_font_description(), index_to_line_x(). 
-	* tools/m4/convert_pango.m4: Added necessary conversion.
-
-2006-06-07  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_enums.defs: Updated with enumpl.
-	* gtk/src/gtk_methods.defs: Updated with h2defs.pyt
-	* gtk/src/notebook.ccg:
-	* gtk/src/notebook.hg: Added set_group_id(), get_group_id(), 
-	get_tab_reorderable(), set_tab_reorderable(), 
-	get_tab_detachable(), set_tab_detachable().
-	* gtk/src/printcontext.hg: Added set_cairo_context().
-	* gtk/src/printoperation.hg: run(): Added PrintOperationAction 
-	parameter.
-	* tools/m4/convert_gtk.m4: Added necessary conversion.
-
-2.9.4:
-
-2006-06-06  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_methods.defs: Updated with h2defs.py.
-
-2006-06-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printcontext.hg: get_cairo() renamed to get_cairo_context(), 
-	get_fontmap() renamed to get_pango_fontmap(), 
-	create_context() renamed to create_pango_context(), 
-	create_layout() renamed to create_pango_layout(), to match the changes in 
-	GTK+.
-	* gtk/src/printjob.ccg:
-	* gtk/src/printjob.hg: send(): Handle the exception and add the ifdefed 
-	alternative for --enable-api-exceptions=no.
-	Comment out get_surface() const, because it does not seem to build with 
-	--enable-api-exceptions at the moment. Added a TODO for that.
-
-2006-05-29  Murray Cumming  <murrayc@murrayc.com>
-
-	* pango/src/Makefile_list_of_hg.am_fragment:
-	* pango/src/cairofontmap.ccg:
-	* pango/src/cairofontmap.hg: Added wrapper of the CairoFontMap interface.
-	* pango/src/context.ccg:
-	* pango/src/context.hg: Added update_from_cairo_context(), 
-	set_cairo_font_options(), set_cairo_font_options(), get_font_options(), 
-	set_resolution(), get_resolution().
-	* pango/src/glyphstring.ccg:
-	* pango/src/glyphstring.hg: Added TODO for pango_cairo_glyph_string_path().
-	* pango/src/layout.ccg:
-	* pango/src/layout.hg: Added create(Cairo::Context), update_from_cairo_context(), 
-	add_to_cairo_context()
-	* pango/src/layoutline.ccg:
-	* pango/src/layoutline.hg: Added show_in_cairo_context(), add_to_cairo_context().
-	* pango/src/pango_methods.defs: Updated with h2defs.py.
-	* tools/m4/convert_pango.m4: Added necessary conversions.
-
-2006-05-26  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* examples/treemodelcustom/exampletreemodel.cc: remove interface
-	registration statements from constructor of the example custom treemodel
-	which were causing runtime warnings.
-
-2006-05-26  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/custom/custom_widget/custom_gtkrc: Add the type prefix 
-	in the style block, which is apparently needed, though it still says it 
-	is an invalid identifier.
-	* examples/book/custom/custom_widget/mywidget.cc: Use _ instead of - 
-	for the style name, in case that is a problem.
-
-2006-05-26  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/reference/Doxyfile.in: In PREDEFINED, set 
-	GLIBMM_VFUNCS_ENABLED, GLIBMM_PROPERTIES_ENABLED, and 
-        GLIBMM_EXCEPTIONS_ENABLED so that those parts of the API 
-	show up in the documentation.
-	* examples/book/custom/custom_widget/custom_gtkrc:
-	* examples/book/custom/custom_widget/mywidget.cc:
-	Attempt (so far unsuccessfully) to show how to make an 
-	aspect of a custom widget themable.
-
-2006-05-22  Marko Anastasov <marko@marko.anastasov.name>
-
-        * gtk/src/gtk_methods.defs: Regenerated with h2defs.py.
-        * gtk/src/gtk_signals.defs: Added paginate signal for PrintOperation.
-        * gtk/src/printer.hg: Ignore gtk_printer_compare.
-        * gtk/src/printjob.hg: Added set/get_track_print_status().
-        * gtk/src/printoperation.hg: Added set_track_print_status() and cancel()
-        methods, paginate signal.
-
-2006-05-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: RefPtr appendix: Reword the bit about using 
-	an official shared_ptr<>. It would not be that easy.
-	* gtk/src/gtk_docs_override.xml: gtk_table_get_homogenous(). Override because 
-	gtk_table_get_homogenous() is for some reason not being automatically changed to 
-	get_homongenous().
-
-2.9.3:
-
-2006-05-18  Murray Cumming  <murrayc@murrayc.com>
-
-        * gdk/src/pixbufloader.hg: Add _CONVERSION() needed by write(), now that
-        glibmm actually does the conversion.
-        * gtk/src/editable.hg: Use _VFUNC_H() as we did before the big #ifdef changes.
-        There is no need to stop using it, and it keeps the vfunc order the same as before.
-
-2006-05-16  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: update the appendix of the tutorial about
-	building with jhbuild
-
-2006-05-16  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/Makefile.am: fix tutorial stylesheet location so that
-	locally installed documentation can find the stylesheet.  Now the locally
-	installed documentation and the published website documentation both install
-	the stylesheet in the same relative location.
-
-2006-05-16  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/pagesetupunixdialog.ccg:
-	* gtk/src/pagesetupunixdialog.hg: Changed constructor to make parent be the
-	first parameter, and added an overload without it.
-	* gtk/src/printjob.hg:
-	* gtk/src/printoperation.hg: Fix some property wrappers to take RefPtrs when
-	a property is a Glib object.
-	* gtk/src/printunixdialog.ccg:
-	* gtk/src/printunixdialog.hg: Constructor and property changes as above.
-
-2006-05-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/actiongroup.ccg: add(): Pass char** instead of char*.
-
-2006-05-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/actiongroup.ccg: add(): Use NULL instead of 0 with g_object_get(), to 
-	avoid the warning about a missing sentinel.
-
-2006-05-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/actiongroup.ccg: add(): Use g_object_get(), not 
-	g_object_get_data() to get property data. Fixes a memory corruption crash.
-	This was another regression introduced by the optional API changes.
-	Bug #341895 from Philip Langdale.
-
-2006-05-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/pagesetupunixdialog.hg:
-	* gtk/src/printunixdialog.hg: Added TODO comments.
-	* gtk/src/printer.hg:
-	* gtk/src/printjob.hg: set_source_file(): Changed filename parameter 
-	from ustring to std::string. 
-	* tools/m4/convert_gtk.m4: Remove an unnecessary conversion.
-
-2006-05-16  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/pagesetupunixdialog.ccg:
-	* gtk/src/pagesetupunixdialog.hg:
-	* gtk/src/printer.ccg:
-	* gtk/src/printer.hg:
-	* gtk/src/printjob.ccg:
-	* gtk/src/printjob.hg:
-	* gtk/src/printunixdialog.ccg:
-	* gtk/src/printunixdialog.hg: New files - Unix printing API.
-	* gtk/src/gtk_signals.defs: Added signal and property defs for new files.
-	* gtk/src/printcontext.hg : Fixed typo for get_cairo()
-	and brought back create_layout().
-	* gtk/src/Makefile_list_of_hg.am_fragment:
-	* gtk/gtkmm.h: Include new files.
-	* tools/extra_defs_gen/generate_defs_gtk.cc: Added get_defs() calls
-	for new types, but commented because the current gtk.h doesn't include
-	their headers.
-	* tools/m4/convert_gtk.m4: Added conversions for GtkPrinter.
-
-2006-05-16  Paul Davis  <pjdavis@engineering.uiowa.edu>
-
-	* gtk/src/table.hg: fix error when trying to remove a widget from a table
-	using Table_Helpers::TableList.erase() (fixes bug #341962)
-
-2006-05-15  Murray Cumming  <murrayc@murrayc.com
-
-	* docs/tutorial/gtkmm-tut.xml: Some typo corrections from Simon Fuhrmann.
-
-2006-05-13  Murray Cumming  <murrayc@murrayc.com
-
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py
-	* gtk/src/printoperation.hg: Change set_nr_of_pages() to set_n_pages().
-	* gtk/src/printsettings.hg: Change set/get_num_copies() to set/get_n_copies().
-	* gtk/src/recentmanager.hg: add_full(): This no longer throws an 
-	exception.
-
-2.9.2:
-
-2006-05-12  Murray Cumming  <murrayc@murrayc.com
-
-	* gtk/src/uimanager.ccg: Fix a typo to fix the build when not disabling 
-	exceptions.
-
-2.9.1:
-
-2006-05-11  Murray Cumming  <murrayc@murrayc.com
-
-	* demos/gtk-demo/demowindow.cc:
-	* demos/gtk-demo/example_iconview.cc: More adapting for the optional API.
-
-2006-05-11  Murray Cumming  <murrayc@murrayc.com
-
-	* demos/gtk-demo/demo-common.cc:
-	* demos/gtk-demo/example_iconview.cc:
-	* demos/gtk-demo/example_images.cc:
-	* demos/gtk-demo/example_pixbufs.cc:
-	* demos/gtk-demo/example_textview.cc:
-	* demos/gtk-demo/example_uimanager.cc:
-	* demos/pixbuf-demo.cc:
-	* docs/tutorial/Makefile.am:
-	* examples/book/custom/custom_container/examplewindow.cc:
-	* examples/book/iconview/examplewindow.cc:
-	* examples/book/input/main.cc:
-	* examples/book/menus/main_menu/examplewindow.cc:
-	* examples/book/menus/popup/examplewindow.cc:
-	* examples/book/menus_and_toolbars/examplewindow.cc:
-	* examples/book/recent_files/examplewindow.cc:
-	* examples/exception/exceptiontest.cc:
-	* gdk/src/pixbuf.ccg:
-	* gdk/src/pixbuf.hg:
-	* gdk/src/pixbufloader.ccg:
-	* gdk/src/pixbufloader.hg:
-	* gtk/gtkmm/cellrenderer_generation.cc:
-	* gtk/gtkmm/treeview_private.cc:
-	* gtk/src/aboutdialog.ccg:
-	* gtk/src/assistant.ccg:
-	* gtk/src/celllayout.ccg:
-	* gtk/src/cellrendereraccel.ccg:
-	* gtk/src/cellrendereraccel.hg:
-	* gtk/src/cellrendererspin.ccg:
-	* gtk/src/cellrendererspin.hg:
-	* gtk/src/clipboard.ccg:
-	* gtk/src/colorselection.ccg:
-	* gtk/src/container.ccg:
-	* gtk/src/entrycompletion.ccg:
-	* gtk/src/filefilter.ccg:
-	* gtk/src/iconview.ccg:
-	* gtk/src/main.ccg:
-	* gtk/src/menu.ccg:
-	* gtk/src/menuitem.ccg:
-	* gtk/src/menushell.ccg:
-	* gtk/src/printoperation.ccg:
-	* gtk/src/printsettings.ccg:
-	* gtk/src/recentchooser.ccg:
-	* gtk/src/recentfilter.ccg:
-	* gtk/src/textiter.hg:
-	* gtk/src/treedragsource.ccg:
-	* gtk/src/treemodel.ccg:
-	* gtk/src/treemodelfilter.ccg:
-	* gtk/src/treeselection.ccg:
-	* gtk/src/treesortable.ccg:
-	* gtk/src/treeview.ccg:
-	* gtk/src/uimanager.ccg:
-	* gtk/src/uimanager.hg:
-	* gtk/src/widget.ccg:
-	* pango/src/fontset.ccg:
-	* tests/main_with_options/main.cc: More adapting for the optional API.
-
-2006-05-11  Murray Cumming  <murrayc@murrayc.com
-
-	* gdk/src/pixbuf.ccg:
-	* gdk/src/pixbuf.hg:
-	* gtk/gtkmm/treeview_private.cc:
-	* gtk/src/aboutdialog.ccg:
-	* gtk/src/clipboard.ccg: 
-	* gtk/src/treemodel.ccg:
-	* gtk/src/treemodelfilter.ccg:
-	* gtk/src/treeselection.ccg:
-	* gtk/src/treesortable.ccg:Added missing #ifdefs needed for use of 
-	--enable-api-exceptions=no with glibmm.
-
-2006-05-10  Murray Cumming  <murrayc@murrayc.com
-
-	* configure.in: Don't build examples/cellrenderercustom because 
-	it needs too much #ifdefing when properties are disabled.
-	* gtk/src/printcontext.ccg:
-	* gtk/src/printcontext.hg:
-	* gtk/src/printoperation.hg: Fix the build by adding a conversion 
-	for the signal, and by removing the unnecessary method implementation.
-
-2006-02-15  Murray Cumming  <murrayc@murrayc.com
-
-	* demos/gtk-demo/demowindow.cc:
-	* demos/gtk-demo/example_menus.cc:
-	* demos/gtk-demo/example_textview.cc:
-	* demos/gtk-demo/example_treeview_editable_cells.cc:
-	* demos/gtk-demo/example_treeview_liststore.cc:
-	* demos/gtk-demo/example_treeview_treestore.cc:
-	* demos/gtk-demo/textwidget.cc:
-	* examples/book/treeview/combo_renderer/examplewindow.cc:
-	* examples/book/treeview/editable_cells/examplewindow.cc:
-	* examples/book/treeview/list/examplewindow.cc:
-	* examples/cellrenderercustom/cellrendererpopup.cc:
-	* examples/cellrenderercustom/cellrenderertoggle.cc:
-	* examples/cellrenderercustom/testpopup.cc:
-	* examples/rulers/rulers.cc:
-	* gtk/gtkmm/cellrenderer_generation.cc:
-	* gtk/gtkmm/cellrenderer_generation.h:
-	* gtk/src/action.ccg:
-	* gtk/src/action.hg:
-	* gtk/src/actiongroup.ccg:
-	* gtk/src/celllayout.ccg:
-	* gtk/src/celllayout.hg:
-	* gtk/src/cellrenderer.ccg:
-	* gtk/src/cellrenderer.hg:
-	* gtk/src/cellrenderercombo.ccg:
-	* gtk/src/cellrenderercombo.hg:
-	* gtk/src/cellrendererpixbuf.ccg:
-	* gtk/src/cellrendererpixbuf.hg:
-	* gtk/src/cellrendererprogress.ccg:
-	* gtk/src/cellrendererprogress.hg:
-	* gtk/src/cellrenderertext.ccg:
-	* gtk/src/cellrenderertext.hg:
-	* gtk/src/cellrenderertoggle.ccg:
-	* gtk/src/cellrenderertoggle.hg:
-	* gtk/src/cellview.ccg:
-	* gtk/src/combobox.ccg:
-	* gtk/src/menuitem.ccg:
-	* gtk/src/texttag.hg:
-	* gtk/src/treeview.hg:
-	* gtk/src/treeviewcolumn.ccg:
-	* gtk/src/treeviewcolumn.hg: Add #ifdef GLIBMM_ENABLE_PROPERTIES around 
-	uses of property proxies and add the set_property<>("name", value) alternatives, 
-	so gtkmm still builds when using this.
-	* examples/Makefile.am: Disable build of cellrenderercustom because 
-	it needs properties (or too much #ifdefing)
-
-2006-05-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/printcontext.hg: Use an #m4 conversion and _WRAP_METHOD() to 
-	generate get_cairo() instead of hand-coding it.
-	get_page_setup(), get_fontmap(): Return a const instance from the const 
-	overloads.
-        Removed the const overload of create_layout(). If you are creating it then 
-	you probably want to change it.
-	* gtk/src/printoperation.hg: Moved signals to the bottom, where we usually put them.
-	set_pdf_target(): Make the filename parameter a std::string, because the encoding of 
-	filenames is unknown.
-
-2006-05-08  Marko Anastasov  <marko@marko.anastasov.name>
-
-	* gtk/src/pagesetup.hg
-	* gtk/src/pagesetup.ccg
-	* gtk/src/papersize.hg
-	* gtk/src/papersize.ccg
-	* gtk/src/printcontext.hg
-	* gtk/src/printcontext.ccg
-	* gtk/src/printoperation.hg
-	* gtk/src/printoperation.ccg
-	* gtk/src/printsettings.hg
-	* gtk/src/printsettings.ccg: New files - the platform-independent
-	part of the printing API.
-	* gtk/src/enums.hg: Added PageOrientation.
-	* gtk/src/Makefile_list_of_hg.am_fragment
-	* gtk/gtkmm.h: Include new files.
-	* tools/m4/convert_pango.m4
-	* tools/m4/convert_gtk.m4: Added new conversions.
-	* tools/extra_defs_gen/generate_defs_gtk.cc:
-	Added GTK_TYPE_PRINT_OPERATION.
-	* gtk/src/gtk_enums.defs:   Regenerated with enums.pl.
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py.
-	* gtk/src/gtk_signals.defs: Added new properties.
-	* configure.in: Added gtk+-unix-print dependency for upcoming updates.
-
-2006-04-26  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/widget.hg: Added doxygen documentation, marking 
-	signal_get_accessible as deprecated, because it is useless.
-	Bug #338437.
-
-2006-04-24  Armin Burgmeier  <armin@arbur.net>
-
-	* gtk/src/statusicon.ccg: Return value of StatusIcon::create_from_file
-	was undefined, return created StatusIcon instead.
-
-2006-04-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/recent_files/.cvsignore:
-	* examples/book/recent_files/Makefile.am:
-	* examples/book/recent_files/examplewindow.cc:
-	* examples/book/recent_files/examplewindow.h:
-	* examples/book/recent_files/main.cc: Added these missing files, to 
-	fix the build.
-	* gtk/src/widget.hg: Use deprecated option with the 
-	get_accessible keyword, because it should not exist, because it 
-	is actually a vfunc, but a quirk of gmmproc means that it was generated 
-	even though it is in the .defs file as a vfunc.
-
-2006-04-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treesortable.hg: Correct the documentation for 
-	SlotCompare. Bug #339129 from Kevin Daughtridge.
-
-2006-04-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.ccg: Mark treeview_target_row as static, to slightly 
-	reduce code size by preventing it from being exported in the ABI.
-
-2006-04-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* pango/src/fontset.ccg: Remove unnecessary anonymous namespace.
-
-2006-04-18  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/cellrendererspin.[hg|ccg]: New file.
-	* gtk/src/Makefile_list_of_hg.am_fragment: Include new hg file.
-	* gtk/gtkmm.h: Include the new header.
-	* gtk/src/recentchooser.ccg:
-	* gtk/src/recentchooser.hg: Fix some typos.
-
-2006-04-18  Armin Burgmeier  <armin@arbur.net>
-
-	* gtk/src/cellrenderertext.hg: Change type for ellipsize property from
-	bool to Pango::EllipsizeMode. Also added some new properties.
-	(Note: This is technically a small API break, but a break of something 
-	that could not have worked before, and I don't think it's an ABI break
-	Murray.)
-	* gtk/src/gtk_signals.defs: Regenerated to contain the new properties.
-
-2006-04-18  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/filechooser.hg: Correct the signature of the confirm_overwrite 
-	signature. This is technically a small API/ABI break, but any use of the 
-	signal as it was would have caused crashes and memory corruption, so that's 
-	not something that anyone could complain about us not preserving.
-	Bug #338439 from Maxim Udushlivy.
-
-2006-04-14  Murray Cumming  <murrayc@murrayc.com>
-
-	* tools/m4/convert_base.m4: Remove this unused file. It is in glibmm already.
-
-2006-04-13  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/recentchooser.ccg: Convert the SignalProxy to the new style that 
-	uses static functions instead.
-
-2006-04-12  Armin Burgmeier  <armin@arbur.net>
-
-	* gtk/src/recentchooser.hg:
-	* gtk/src/recentchooser.ccg:
-	* gtk/src/recentchooserwidget.hg:
-	* gtk/src/recentchooserwidget.ccg:
-	* gtk/src/recentchoosermenu.hg:
-	* gtk/src/recentchoosermenu.ccg:
-	* gtk/src/recentchooserdialog.hg:
-	* gtk/src/recentchooserdialog.ccg: Wrapped GtkRecentChooser,
-	GtkRecentChooserDialog, GtkRecentChooserMenu and
-	GtkRecentChooserWidget.
-	* tools/m4/convert_gtk.m4: Added new needed conversions.
-	* gtk/gtkmm.h: Include the new headers.
-	* examples/book/recent_files/: The beginning of an example. To complete 
-	this we need to be able to use RecentFilesMenu with UIManager. The GTK+ 
-	developer is working on this.
-
-2006-04-12  Marko Anastasov <marko@marko.anastasov.name>
-
-        * gtk/src/recentinfo.[ccg|hg]: Added new get_applications() and get_groups()
-        functions that don't take length as a parameter but pass NULL to the
-        underlaying GTK+ functions.
-        * tools/m4/convert_gtk.m4: Removed now unnecessary gsize* to unsigned& conversion.
-
-2006-04-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/recentfilter.ccg: Fix some typos to fix the build. 
-	Use the new non-class SignalProxy callbacks idea. (See below)
-
-	* atk/src/hyperlink.hg:
-	* atk/src/hypertext.hg:
-	* atk/src/objectaccessible.hg:
-	* atk/src/table.hg:
-	* gdk/src/colormap.hg:
-	* gdk/src/cursor.hg:
-	* gdk/src/display.hg:
-	* gdk/src/displaymanager.hg:
-	* gdk/src/drawable.hg:
-	* gdk/src/event.hg:
-	* gdk/src/gc.hg:
-	* gdk/src/image.hg:
-	* gdk/src/screen.hg:
-	* gdk/src/visual.hg:
-	* gdk/src/window.hg:
-	* gtk/src/aboutdialog.hg:
-	* gtk/src/accellabel.hg:
-	* gtk/src/actiongroup.hg:
-	* gtk/src/assistant.hg:
-	* gtk/src/button.hg:
-	* gtk/src/clipboard.hg:
-	* gtk/src/combobox.hg:
-	* gtk/src/container.hg:
-	* gtk/src/entry.hg:
-	* gtk/src/entrycompletion.hg:
-	* gtk/src/expander.hg:
-	* gtk/src/filechooser.hg:
-	* gtk/src/frame.hg:
-	* gtk/src/iconinfo.hg:
-	* gtk/src/iconsource.hg:
-	* gtk/src/iconview.hg:
-	* gtk/src/image.hg:
-	* gtk/src/imagemenuitem.hg:
-	* gtk/src/invisible.hg:
-	* gtk/src/label.hg:
-	* gtk/src/layout.hg:
-	* gtk/src/menu.hg:
-	* gtk/src/menuitem.hg:
-	* gtk/src/menutoolbutton.hg:
-	* gtk/src/notebook.hg:
-	* gtk/src/optionmenu.hg:
-	* gtk/src/paned.hg:
-	* gtk/src/range.hg:
-	* gtk/src/scale.hg:
-	* gtk/src/scrolledwindow.hg:
-	* gtk/src/selectiondata.hg:
-	* gtk/src/spinbutton.hg:
-	* gtk/src/statusicon.hg:
-	* gtk/src/textbuffer.hg:
-	* gtk/src/textmark.hg:
-	* gtk/src/texttagtable.hg:
-	* gtk/src/textview.hg:
-	* gtk/src/toolbar.hg:
-	* gtk/src/toolbutton.hg:
-	* gtk/src/toolitem.hg:
-	* gtk/src/treemodelfilter.hg:
-	* gtk/src/treemodelsort.hg:
-	* gtk/src/treerowreference.hg:
-	* gtk/src/treeselection.ccg:
-	* gtk/src/treeselection.hg:
-	* gtk/src/treeview.hg:
-	* gtk/src/uimanager.hg:
-	* gtk/src/viewport.hg:
-	* gtk/src/widget.hg:
-	* gtk/src/window.hg: Use the new constversion option with _WRAP_METHOD() 
-	to reduce code size a little.
-
-2006-04-07  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/gtkmm/treeview_private.cc:
-	* gtk/gtkmm/treeview_private.h:
-	* gtk/src/aboutdialog.ccg:
-	* gtk/src/assistant.ccg:
-	* gtk/src/celllayout.ccg:
-	* gtk/src/clipboard.ccg:
-	* gtk/src/combobox.ccg:
-	* gtk/src/entrycompletion.ccg:
-	* gtk/src/filefilter.ccg:
-	* gtk/src/menu.ccg:
-	* gtk/src/texttagtable.ccg:
-	* gtk/src/treemodelfilter.ccg:
-	* gtk/src/treeselection.ccg:
-	* gtk/src/treesortable.ccg:
-	* gtk/src/treeview.ccg:
-	* gtk/src/treeviewcolumn.ccg: For most hand-coded SignalProxy classes, used 
-	for set_*func() methods, remove them and just pass a copy of the slot around. 
-	The extra indirection is not necessary. Use standalone callback functions, so 
-	that they can be static, saving a few bytes on the library size.
-
-2006-04-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/pixbuf.ccg:
-	* gdk/src/pixbufloader.ccg:
-	* gtk/src/colorselection.ccg:
-	* gtk/src/container.ccg:
-	* gtk/src/entrycompletion.ccg:
-	* gtk/src/iconview.ccg:
-	* gtk/src/treeiter.ccg:
-	* gtk/src/treemodel.ccg:
-	* gtk/src/treeselection.ccg:
-	* gtk/src/widget.ccg:
-	* pango/src/fontset.ccg: Mark private functions as static, 
-	to stop them being exported in the library, to reduce code size 
-	slightly.
-
-2006-04-11  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* gtk/src/icontheme.ccg: (IconTheme::get_search_path) fixed a segfault
-	caused by de-referencing a NULL pointer, and also fixed a memory leak by
-	freeing the list of search paths whose storage was allocated by GTK+.
-	Closes bug #337874 and #337875
-
-2006-04-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/recentfilter.ccg:
-	* gtk/src/recentfilter.hg: Added constructor for the Info 
-	inner class, so that the member variables are initialized.
-	* gtk/src/recentinfo.hg: Split get_icon() into const and non-const 
-	overloads.
-	* gtk/src/recentmanager.hg: Added TODO comment for documentation.
-
-2006-04-11  Marko Anastasov <marko@marko.anastasov.name>
-
-	* gtk/src/recentfilter.[hg|ccg]:
-	* gtk/src/recentinfo.[hg|ccg]:
-	* gtk/src/recentmanager.[hg|ccg]:
-	* gtk/src/Makefile_list_of_hg.am_fragment: Added new files.
-	* tools/m4/convert_gtk.m4: Add new needed conversions.
-	* gtk/gtkmm.h: include the new headers.
-
-2006-04-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in:
-	* examples/book/treeview/Makefile.am:
-	* examples/book/treeview/modelsort/.cvsignore:
-	* examples/book/treeview/modelsort/Makefile.am:
-	* examples/book/treeview/modelsort/examplewindow.cc:
-	* examples/book/treeview/modelsort/examplewindow.h:
-	* examples/book/treeview/modelsort/main.cc: Added example of 
-	independently sorted model, with the TreeModelSort parent model. 
-
-2006-04-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/gtkmm/listviewtext.cc: Constructor: Use sprintf() instead of 
-	std::stringstream because it is smaller (code size) and faster.
-
-2006-04-07  Cedric Gustin  <cedric.gustin@gmail.com>
-
-	* README.win32: Updated for gtkmm-2.8 (MS Visual Studio 2005).
-	* MSVC_Net2003/*.vcproj: Updated for Visual Studio 2005. Added the
-	/vd2 compiler flag (Bug #158040).
-	* MSVC_Net2003/gtkmm.sln: Updated for Visual Studio 2005.
-	* MSVC_Net2003/gendef/gendef.cc: Redirect output of dumpbin to a
-	file.
-	* build_shared/Makefile_build.am_fragment: Add -DGTKMM_BUILD to
-	the extra_defines compiler flags (switch between
-	dllexport/dllimport on win32).
-	* gtk/src/treeviewcolumn.hg: Tag the TreeViewColumn class with
-	GTKMM_API to avoid auto-import errors with gcc on
-	mingw32/cygwin. Also inline some TreeViewColumn methods. Bug
-	#309030 (Toralf Lund).
-	* gtk/src/object.hg: Tag the Object class with GTKMM_API to make
-	Visual Studio happy.
-
-2006-04-04  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: fixed a few broken links in the jhbuild
-	appendix
-
-2006-03-31  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py.
-	* tools/extra_defs_gen/generate_defs_gtk.cc: Added 
-	GTK_TYPE_CELL_RENDERER_SPIN, GTK_TYPE_RECENT_CHOOSER, 
-	GTK_TYPE_RECENT_CHOOSER_MENU, GTK_TYPE_RECENT_CHOOSER_WIDGET, 
-	GTK_TYPE_RECENT_FILTER, GTK_TYPE_RECENT_MANAGER )
-	* gtk/src/gtk_signals.defs: Added sections for the new types.
-
-
-2006-03-28  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_docs_override.xml: Added override for 
-	gtk_widget_render_icon(), because it mentioned unrefing the result.
-
-2006-03-26  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/gdk_docs_override.xml: Override the documentation for 
-	create_cairo_context because it mentions destroying the result, 
-	and says that it is since 2.8 instead of 2.10.
-
-2006-03-23  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/pixbufloader.hg: create(): Add documentation, based on 
-	new C documentation.
-
-2006-03-22  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/Makefile.am: Add style.css to EXTRA_DIST.
-	* docs/tutorial/gtkmm-tut.xml: TreeView chapter: Add a 
-	sub-section about sorting, mentioning the simple set_sort_column() 
-	functions and TreeModelSort for independent sorting. Based on 
-	code from the example from R. Douglas Barbieri in bug #334791.
-
-2006-03-22  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/src/dragcontext.hg: Added set_icon_name().
-	* gtk/src/toolbutton.hg: Added set_icon_name() and 
-	get_icon_name().
-	* gdk/src/pixbuf.hg:
-	* gdk/src/pixbufloader.ccg:
-	* gdk/src/pixbufloader.hg:
-	* gtk/src/aboutdialog.hg:
-	* gtk/src/dialog.hg:
-	* gtk/src/iconview.hg:
-	* gtk/src/linkbutton.hg:
-	* gtk/src/textbuffer.hg:
-	* gtk/src/textchildanchor.hg:
-	* gtk/src/treemodelsort.hg: Added documentation, based on 
-	the C documentation.
-
-2006-03-22  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.in:
-	* examples/book/Makefile.am:
-	* examples/book/iconview/Makefile.am:
-	* examples/book/iconview/examplewindow.cc:
-	* examples/book/iconview/examplewindow.h:
-	* examples/book/iconview/main.cc: Added example from 
-	R. Douglas Barbieri in bug #335388.
-	* examples/book/iconview/gnome-dice-1.svg:
-	* examples/book/iconview/gnome-dice-2.svg:
-	* examples/book/iconview/gnome-dice-3.svg:
-	* examples/book/iconview/gnome-dice-4.svg:
-	* examples/book/iconview/gnome-dice-5.svg:
-	* examples/book/iconview/gnome-dice-6.svg:
-	* examples/book/iconview/mozilla-firefox.png:
-	* examples/book/iconview/xmms.xpm: Sample images for the 
-	example.
-
-2006-03-22  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/index.html: Corrected links to chapters, now that 
-	we added a chapter in the middle. Bug #334989 from Rob Page.
-	* gtk/gtkmm/listviewtext.h: Added groups and newin doxygen 
-	tags.
-
-2006-03-22  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/gtkmm/listviewtext.cc:
-	* gtk/gtkmm/listviewtext.h: Renamed some member variables, and 
-	used ModelColumns via member instance instead of pointer, to 
-	simplify code.
-	* configure.in:
-	* examples/book/treeview/Makefile.am:
-	* examples/book/treeview/listviewtext/Makefile.am:
-	* examples/book/treeview/listviewtext/examplewindow.cc:
-	* examples/book/treeview/listviewtext/examplewindow.h:
-	* examples/book/treeview/listviewtext/main.cc: Added example, 
-	based on treeview/list example.
-	* gtk/gtkmm.h: Include listviewtext.h
-
-2006-03-22  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/gtkmm/Makefile.am:
-	* gtk/gtkmm/listviewtext.cc:
-	* gtk/gtkmm/listviewtext.h: Added ListViewText, a very simple TreeView 
-	convenience class, from J. Baltasar García Perez-Schofield in bug #329333, 
-	with formatting and constness corrections.
-
-2006-03-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/drawingarea/clock/clock.cc:
-	* examples/book/drawingarea/joins/myarea.cc: Update the cairomm enum values for the 
-	latest cairomm API.
-
-2006-03-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/combobox.hg: Added get/set_title() and corresponding
- 	tearoff-title property.
-	* gtk/src/iconview.ccg:
-	* gtk/src/iconview.hg: Added drag and drop methods.
-	* gtk/src/treeview.hg: Corrected a typo in the documentation.
-	* tools/m4/convert_gtk.m4: Added new enum conversion.
-
-2006-02-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.hg: Remove an extra : after a @deprecated.
-
-2006-02-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Signals appendix: Remove vague uninteresting stuff 
-	about different functor types, and mention sigc::ptr_fun, mem_fun distinction earlier.
-
-o2006-02-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_docs.xml: Regenerate from the C files.
-	* gtk/src/gtk_docs_override.xml: Update the override for gtk_icon_theme_list_icons(), 
-	so that it shows the correct subset examples. Fixes bug #330966 from John Spray 
-
-2006-02-25  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/gtkmm.h: Include layout.h, cellview.h, and icontheme.h.
-	Bug #332447 from Maxim Udushlivy.
-
-2006-02-24  Rob Page  <page.rob@gmail.com>
-
- 	* gtk/src/icontheme.ccg: Change int* to int to fix segfault. Bug #332437.
-
-2006-02-25  Murray Cumming  <murrayc@murrayc.com>
-
-        * gtk/src/calendar.hg:
-        * gtk/src/cellrenderer.hg:
-        * gtk/src/messagedialog.hg:
-        * gtk/src/textview.hg:
-        * gtk/src/treemodelfilter.hg:
-        * gtk/src/treepath.hg:
-        * gtk/src/treeview.hg:
-        * gtk/src/widget.hg: Move the deprecated comment into the _WRAP_METHOD() call,
-        using the new feature in glibmm, so that it really shows up in the doxygen
-        documentation.
-
-2006-02-22  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in: only generate Makefiles for specific features if those
-	features are enabled (e.g. docs, examples, etc)
-
-2006-02-22  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/gtk_docs_override.xml: Added an override for gtk_icon_theme_list_icons() 
-	because it mentions GList, memory management of the items, and providing a NULL 
-	parameter.
-	* gtk/src/icontheme.ccg:
-	* gtk/src/icontheme.hg: Added override of list_icons() that returns all icons, 
-	regardless of context, to match the NULL context case. Bug #330945 from John Spray.
-
-2006-02-18  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: synchronized the list of widgets without
-	windows with the documentation from the Gtk+ tutorial (see
-	http://gtk.org/tutorial/x502.html)
-
-2006-02-18  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/style.css: Fixed a couple of tutorial style issues
-	* docs/tutorial/gtkmm-tut.xml: updated and re-organized the installation
-	section of the tutorial a bit more -- added dependency on cairomm / cairo,
-	reworded a few things, etc.
-	Added a new appendix explaining how to build and install gtkmm from CVS
-	using jhbuild.
-
-2006-02-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/pixbuf.ccg: save_to_buffer(): Use a terminating NULL when
-	calling gdk_pixbuf_save_to_buffer() to avoid a warning about the sentinel.
-
-2006-02-13  Rob Page  <page.rob@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: minor fixes to gettext chapter, a typo and
-	a broken link (Bug #331077)
-
-2006-02-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/assistant.hg: Wrap the prepared signal, now that it is fixed in GTK+.
-	* gtk/src/entry.hg: Add a link to the email that says it is OK to wrap the 
-	activate signal.
-
-2006-02-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/clipboard.hg: Wrap the owner-changed signal, which was new in 
-	GTK+ 2.8, I think. Use no_default_handler to avoid an ABI break.
-	* gtk/src/gtk_signals.defs: Added defs for GtkClipboard.
-	* tools/extra_defs_gen/generate_defs_gtk.cc: Generate .defs for GtkClipboard.
-	Bug #330139 from Jonathan Jongsma.
-
-2006-01-30  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: fixed a minor typo in the clipboard section
-	of the tutorial that referred to get_data_as_text() instead of
-	get_data_as_string()
-
-2006-01-29  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/Makefile.am: Remove unnecessary icons installation line - 
-	it happens in the sub-directory.
-	* docs/tutorial/figures/Makefile.am:
-	* docs/tutorial/figures/comboboxentry_complex.png:
-	* docs/tutorial/figures/comboboxentry_text.png: Added screenshots.
-	* docs/tutorial/gtkmm-tut.xml: Write basic Combo Boxes chapter, replacing the 
-	text about the deprecated Combo widget, and moving it after the TreeView 
-	chapter, because it needs knowledge of the TreeView.
-	* examples/book/combobox/complex/examplewindow.cc:
-	* examples/book/combobox/text/examplewindow.cc:
-	* examples/book/comboboxentry/complex/examplewindow.cc:
-	* examples/book/comboboxentry/text/examplewindow.cc: Removed useless 
-	commented-out code.
-
-2006-01-29  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.hg: Added get_search_entry() and 
-	get_headers_clickable().
-	* tools/m4/convert_gtk.m4: Correct the Entry conversion.
-
-2006-01-29  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/widget.ccg:
-	* gtk/src/widget.hg: Added get_action().
-
-2006-01-29  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/gdkmm/general.cc:
-	* gdk/gdkmm/general.h: Added set_source_pixmap().
-	* gtk/src/Makefile_list_of_hg.am_fragment:
-	* gtk/src/action.ccg:
-	* gtk/src/assistant.ccg:
-	* gtk/src/assistant.hg: Added Assistant.
-	* gtk/src/linkbutton.ccg:
-	* gtk/src/linkbutton.hg: Added LinkButton
-	* gtk/gtkmm.h: include the new headers.
-	* gtk/src/cellrenderertoggle.hg: Added indicator-size property.
-	* gtk/src/messagedialog.hg: Added properties.
-	* gtk/src/radioaction.hg: Added set_current_value().
-	* gtk/src/sizegroup.hg: Added get_widgets().
-	* gtk/src/toolbutton.hg: Deprecated the clicked signal, because 
-	it has become a keybinding/action signal.
-	* gtk/src/treeview.ccg:
-	* gtk/src/treeview.hg: Added set_search_position_func().
-	* gtk/src/window.hg: Added get_group().
-	* tools/extra_defs_gen/generate_defs_gtk.cc: Add the new GTK+ 
-	GTypes.
-	* tools/m4/convert_gtk.m4: Add new needed conversions.
-	* gtk/src/gtk_enums.defs: Regenerated with enums.pl
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py
-	* gtk/src/gtk_signals.defs: Added parts with extra_defs.
-
-2006-01-28  Pierre Thierry  <nowhere.man@levallois.eu.org>
-
-	* examples/book/buttons/radiobutton/radiobuttons.cc: add comments and
-	reorganize the example so that it's a bit more understandable for
-	beginners
-	* gtk/src/box.hg: add brief clarification of where widgets end up when
-	packed with a variety of pack_start() and pack_end() calls
-
-2006-01-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/Makefile.am: Restore html upload line.
-	* docs/tutorial/gtkmm-tut.xml: Contributing: Added links to bugs page. 
-	* gtk/src/radiobutton.hg: Added documentation for get/set/reset_group().
-
-2006-01-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Installation: Move section about 
-	packages before the section about installing from source, so people 
-	see the easiest/best way first. Add warning about installing 
-	source-built stuff in /usr.
-
-2006-01-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/Makefile.am: Upload the style.css file when doing 
-	post-html.
-	* docs/tutorial/gtkmm-tut.xml: Add para tags to tip and note tags, 
-	as noticed by the validate-original make target. Remove some of 
-	the initial paragraph about it being a draft. 
-
-2006-01-24  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/Makefile.am:
-	* docs/tutorial/icons/Makefile.am: Restored some files I messed up 
-	by copying stuff into the wrong place.
-
-2006-01-24  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/tutorial/Makefile.am:
-	* docs/tutorial/icons/Makefile.am:
-	* docs/tutorial/icons/caution.png:
-	* docs/tutorial/icons/home.png:
-	* docs/tutorial/icons/important.png:
-	* docs/tutorial/icons/next.png:
-	* docs/tutorial/icons/note.png:
-	* docs/tutorial/icons/prev.png:
-	* docs/tutorial/icons/tip.png:
-	* docs/tutorial/icons/up.png:
-	* docs/tutorial/icons/warning.png: Added missing files.
-
-2006-01-23  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: improve the markup of the tutorial by
-	replacing a lot of the generic 'literal' tags with more specific ones like
-	'classname' or 'function'.  Also marked up a bunch of things that weren't
-	marked up at all.
-
-2006-01-18  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/figures/Makefile.am:
-	* docs/tutorial/figures/*.png: Several updated screenshots from 
-	Jonathon Jongsma. Bug #327142.
-
-2006-01-18  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/gtk_docs_override.xml: Added some new overrides for functions that 
-	mention free() or NULL.
-
-2006-01-15  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-        * docs/tutorial/Makefile.am: Modified makefile to pass some XSL parameters
-        to the xsltproc.  For example, where to find icon images, what filename to
-        use as a CSS stylesheet, etc.
-        * docs/tutorial/insert_example_code.pl: Modified script to mark up the
-        filename with a docbook 'filename' element so that it can be styled more
-        easily
-        * docs/tutorial/style.css: add a new CSS stylesheet for styling the
-        tutorial.  The CSS is based on the GNOME stylesheets used for yelp but a
-        also designed to fit the theme of the gtkmm website.
-        * docs/tutorial/icons/*.png: add a bunch of images from the tango theme to
-        be used for informational and navigational icons.
-
-2005-12-31  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Add screenshot for the aspectframe example.
-	The screenshot was already in CVS, just not linked from the tutorial.
-
-2005-12-31	Jonathon Jongsma	<jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: updated section on prepackaged gtkmm
-	binaries for linux distributions
-
-2006-01-07  Michael J M Thomson  <mjmt@internode.on.net>
-
-	* gtk/gtkmm.h: Include menutoolbutton.h and tearoffmenuitem.h
-
-2005-12-24  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: quick fix for source code location of
-	cairo simple line drawing example
-
-2006-01-04  Cedric Gustin <cedric.gustin@gmail.com>
-
-	* gtk/src/Makefile_list_of_hg.am_fragment: Moved plug.hg and
-	socket.hg from files_posix_hg to files_general_hg as both GtkPlug
-	and GtkSocket are now supported on win32.
-
-2005-12-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/container.ccg:
-	* gtk/src/container.hg: Use custom_c_callback option 
-	with _WRAP_SIGNAL for the remove signal, so we can 
-	provide a custom signal callback (as well as the existing 
-	custom default signal callback). This allows us to 
-	check for already-deleted children in connected signal handler 
-	callbacks as well as the default signal handler. This should 
-	be a partial fix for bug #315874 from Philip Langdale.
-
-2005-12-23  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: DrawingArea chapter: Move GDK 
-	stuff into an appendix, and remove reference to X, because it is 
-	not always running on X. 
-
-2005-12-23  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/tutorial/figures/Makefile.am: Mention the new screenshots 
-	so they are disted and uploaded.
-	* docs/tutorial/gtkmm-tut.xml: Fix a source code path.
-
-2005-12-21  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* configure.in: added makefiles for new example directories
-	* docs/tutorial/Makefile.am:
-	* docs/tutorial/figures/drawingarea_lines.png:
-	* docs/tutorial/gtkmm-tut.xml:
-	* examples/book/Makefile.am:
-	* examples/book/drawingarea/main.cc:
-	* examples/book/drawingarea/myarea.cc:
-	* examples/book/drawingarea/myarea.h: complete rework of the drawing area
-	chapter of the gtkmm tutorial to use Cairomm for drawing instead of old
-	Gdk functions.  Updated text and examples, and added several new examles.
-
-2005-12-21  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/texttagtable.ccg: Put a private class in a 
-	anonymous namespace, theoretically to prevent it being 
-	exported as ABI. 
-
-2005-12-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/entry.hg: Added xalign and 
-	truncate-multiline properties.
-
-2005-12-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/drawingarea/myarea.cc:
-	* gdk/gdkmm/general.cc:
-	* gdk/gdkmm/general.h:
-	* gdk/src/drawable.hg: Use Cairo objects via 
-	Cairo::RefPtr.
-
-2005-12-15  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/adjustment.ccg:
-	* gtk/src/adjustment.hg: Generate the constructor, 
-	instead of hand coding it, because it now uses properties.
-
-2005-12-15  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in:
-	* examples/book/Makefile.am:
-	* examples/book/statusicon/.cvsignore:
-	* examples/book/statusicon/main.cc:
-	Add example.
-	* gtk/gtkmm.h: #include statusicon.h and 
-	cellrendereraccel.h.
-	* gtk/src/statusicon.hg: Rename parameter name for 
-	stock constructor, so it uses the correct property name.
-
-2005-12-15  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/object.hg: Add class documentation, based on 
-	the C documentation. Add documentation for manage().
-
-2005-12-14  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/src/types.hg: Hide traits from Doxygen.
-
-2005-12-14  Philip Langdale  <plangdale@vmware.com>
- 
- 	* gdk/src/window.hg:
- 	* tools/m4/convert_gdk.m4: Correct the Cursor 
- 	conversion - it does not need to be copied/leaked. 
- 	Bug #323920.
-
-2005-12-12  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.in: Depend on gtk+ 2.9.
-	* gtk/src/Makefile_list_of_hg.am_fragment:
-	* gtk/src/cellrendereraccel.ccg:
-	* gtk/src/cellrendereraccel.hg: New CellRenderer.
-	* gtk/gtkmm/cellrenderer_generation.cc:
-	* gtk/gtkmm/cellrenderer_generation.h: 
-	Add a template specialization for AccelKey model 
-	columns.
-	* gtk/src/filechooserbutton.hg: Add 
-	set/get_focus_on_click() and property.
-	* gtk/src/menu.ccg:
-	* gtk/src/menu.hg: Add attach_to_widget() overload 
-	without a destroy callback.
-	* gtk/src/range.hg: Added 
-	get/set_lower_stepper_sensitivity(),
-	get/set_upper_stepper_sensitivity() and properties.
-	* gtk/src/selectiondata.hg: Added targets_include_uri().
-	* gtk/src/statusicon.ccg:
-	* gtk/src/statusicon.hg: New class.
-	* gtk/src/style.hg: Added lookup_color().
-	* gtk/src/textbuffer.hg: Added get_has_selection() and 
-	property. Added text property.
-	* gtk/src/window.hg: Added get/set_deletable() and 
-	property.
-	* tools/extra_defs_gen/generate_defs_gtk.cc: Add new types.
-	* tools/m4/convert_gtk.m4: Add new conversions.
-	* gtk/src/gtk_docs.xml: Update.
-	* gtk/src/gtk_enums.defs: Update
-	* gtk/src/gtk_methods.defs: Update
-	* gtk/src/gtk_signals.defs: Update
-
-2005-12-10  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/expander.hg: Add documentation, base on the 
-	C documentation, mentioning property_expanded().signal_changed().
-
-2005-12-10  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/object.ccg: Use g_object_sink_ref() and 
-	friends instead of now-deprecated gtk_object_sink(). 
-	Maybe it works.
-
-2005-12-06  Jonathon Jongsma  <jonathon.jongsma@gmail.com>
-
-	* Makefile.am:
-	* configure.in: add configure option for enabling / disabling building of
-	documentation (--enable-docs / --disable-docs)
-
-2005-12-06   Jonathon Jongsma <jonathon.jongsma@gmail.com>
-
-	* configure.in: Look for gmmproc in generic libdir 
-	directory, because that is not always lib/. This 
-	fixes the build on some 64-bit systems.
-
-2005-12-06   Jonathon Jongsma <jonathon.jongsma@gmail.com>
-
-	* gdk/gdkmm-2.4.pc.in: Add cairomm to dependencies. 
-	Bug #323347.
-
-2005-12-02  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/reference/Doxyfile.in: Reword the title of the 
-	since pages, to make it clear that they do not include 
-	new API in subsequent versions.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/gdkmm/general.h: Mark cairo API as new in 2.10.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/treemodel.ccg:
-	* gtk/src/treemodel.hg: Added a method overload of 
-	rows_reordered() without the iter, because the GTK+ docs 
-	now say that it can be 0. Added documentation, based on the 
-	C documentation.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com
-
-	* examples/book/drawingarea/myarea.cc: 
-	on_expose_event(): Port to cairo instead of 
-	draw*(), though the Color and GC part should 
-	probably be ported too.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.in: Depend on cairomm.
-	* gdk/gdkmm/general.cc:
-	* gdk/gdkmm/general.h:
-	* gdk/src/drawable.hg: Use C++ Cairo:: types instead of 
-	C cairo_* types.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/reference/Doxyfile.in: Add a newline after the 
-	newin xrefitem, to stop doxgygen associating the following 
-	text with the xrefitem, so properties and returns do not 
-	show up in the list of new API.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Remove link to 
-	non-existing drawing_area_text example. 
-	Bug #311176 from Jonathon Jongsma.
-
-2005-11-30  Murray Cumming <murrayc@murrayc.com>
- 
- 	* docs/index.html: Change deprecated link to link to 
- 	deprecated and new pages page.
- 	* gdk/src/gdk_docs_override.xml:
- 	* gtk/src/gtk_docs_override.xml: Change Since: to 
- 	our @newin tags.
-
-2005-11-30  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/reference/Doxyfile.in: Added ALIASES 
-	for @newin2p2, @newin2p4, @newin2p6, @newin2p8, and 
-	@newin2p10. API marked with these tags will then be 
-	listed together on a page. Doxygen already has @since, 
-	but that does not list them on one page.
-	* gdk/src/displaymanager.hg:
-	* gtk/gtkmm/accelmap.h:
-	* gtk/src/cellrenderer.hg:
-	* gtk/src/clipboard.hg:
-	* gtk/src/colorbutton.hg:
-	* gtk/src/entrycompletion.hg:
-	* gtk/src/expander.hg:
-	* gtk/src/filechooserwidget.hg:
-	* gtk/src/messagedialog.hg:
-	* gtk/src/radiotoolbutton.hg:
-	* gtk/src/rc.hg:
-	* gtk/src/uimanager.hg:
-	* pango/src/fontset.hg: Replace any Since: text with 
-	the new tags.
-
-2005-11-30  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.in:
-	* gtk/gtkmmconfig.h.in: Check for the mkifofs() 
-	function (not available in windows, apparently), and 
-	define HAVE_MKIFOFS.
-	* examples/book/input/main.cc: Do not use mkifofs 
-	if it is not present, to fix build on Windows.
-	Bug #309031 from haleykd.
-
-2005-11-30  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/gtkmm/accelmap.cc:
-	* gtk/gtkmm/accelmap.h: Added lookup_entry(), wrapping 
-	gtk_accel_map_lookup_entry, based on code provided by 
-	Paul Davis in bug #318407.
-
-2005-11-30  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/style.ccg: Fix the cast, to fix the build
-
-2005-11-29  Murray Cumming <murrayc@murrayc.com>
-
-	* build_shared/Makefile_build.am_fragment:
-	* configure.in: Added --enable-deprecated-api option: 
-	Set it to yes to remove deprecated API from the library, 
-	for instance for embedded devices.
-	* gdk/src/color.ccg:
-	* gdk/src/color.hg:
-	* gdk/src/colormap.ccg:
-	* gdk/src/colormap.hg:
-	* gdk/src/image.hg:
-	* gdk/src/window.hg:
-	* gtk/src/calendar.hg:
-	* gtk/src/cellrenderer.hg:
-	* gtk/src/combo.hg:
-	* gtk/src/fileselection.hg:
-	* gtk/src/inputdialog.hg:
-	* gtk/src/messagedialog.hg:
-	* gtk/src/optionmenu.hg:
-	* gtk/src/progress.hg:
-	* gtk/src/textbuffer.ccg:
-	* gtk/src/textbuffer.hg:
-	* gtk/src/textview.ccg:
-	* gtk/src/textview.hg:
-	* gtk/src/toolbar.hg:
-	* gtk/src/treemodel.hg:
-	* gtk/src/treemodelfilter.hg:
-	* gtk/src/treepath.ccg:
-	* gtk/src/treepath.hg:
-	* gtk/src/treesortable.ccg:
-	* gtk/src/treesortable.hg:
-	* gtk/src/treeview.ccg:
-	* gtk/src/treeview.hg:
-	* gtk/src/treeviewcolumn.ccg:
-	* gtk/src/treeviewcolumn.hg:
-	* gtk/src/widget.hg: Use the new gmmproc features to 
-	ifdef-out the deprecated API.
-	* tests/menu_destruction/main.cc:
-	* demos/gtk-demo/example_iconview.cc:
-	* demos/gtk-demo/example_menus.cc:
-	* demos/gtk-demo/example_sizegroup.cc:
-	* demos/gtk-demo/example_textview.cc: 
-	* examples/Makefile.am_fragment:
-	* examples/book/custom/custom_container/mycontainer.cc:
-	* examples/book/dialogs/fileselection/examplewindow.cc:
-	* examples/book/range_widgets/labeledoptionmenu.cc:
-	* examples/book/range_widgets/labeledoptionmenu.h:
-	* examples/cellrenderercustom/popupentry.cc:
-	* examples/stock/stock.cc: Do not use deprecated API.
-
-2005-11-29  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/style.ccg:
-	* gtk/src/style.hg: Added an overload 
-	of set_bg_pixmap() that takes a const 
-	Pixmap, and deprecated the non-const one, 
-	because the pixmap contents are not changed
-	by the method. Bug #313309 from Michael Hofmann.
-
-2005-11-29  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/index.html: Added a link to the 
-	generated list of deprecated API.
-
-2005-11-29  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/src/window.hg: Added set_urgency_hint().
-
-2005-11-28  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/textbuffer.hg: Added const overloads of 
-	get_text() and get_slice(), deprecating the non-const 
-	versions. Bug #322338 from Ami Tavory.
-
-2005-11-22  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.in:
-	* examples/book/Makefile.am:
-	* examples/book/update_ui/Makefile.am:
-	* examples/book/update_ui/examplewindow.cc:
-	* examples/book/update_ui/examplewindow.h:
-	* examples/book/update_ui/main.cc: Add an example 
-	that uses events_pending() to update the UI, loosely 
-	based on bug #317424 from Gareth Foster.
-
-2005-11-22  Murray Cumming <murrayc@murrayc.com>
-
-	* pango/src/attrlist.ccg:
-	* pango/src/attrlist.hg: Add operator(), because 
-	some methods return null PangoAttrList*s.
-
-2005-11-21  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/gdkmm/general.cc:
-	* gdk/gdkmm/general.h: Added wrappers for gdk cairo functions, 
-	though we need a real cairo Context class, from a real cairo C++ 
-	API.
-	* gdk/src/drawable.hg: Add TODO about a gdk cairo function.
-	* gtk/src/treeview.hg: Do not use g_asssert in a header, to 
-	avoid a warning about a useless command.
-
-
-2005-11-16  Michael J M Thomson <mjmt@internode.on.net>
-
-	* gdk/src/gc.hg: GC::set_clip_rectangle(): Add a 
-	method overload that takes a const argument, and 
-	deprecate the non-const version. Bug #320631.
-
-2005-11-16  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/widget.hg: Made map() public, 
-	because custom containers sometimes (e.g. GtkNotebook) 
-	need to call it on their child widgets, though we are 
-	not sure when. Bug #320631.
-
-This is the HEAD branch, for new API.
-
-2.8.1:
-
-2005-08-02  Marco Scholten <mscholtn@xs4all.nl>
-
-	* docs/tutorial/gtkmm-tut.xml: changed square to 
-	Penrose triangle and added the missing screenshot
-	in the custom widget chapter.
-	Bug #311176.
-
-2005-10-19  Murray Cumming <murrayc.com>
-
-	* gtk/src/uimanager.hg: Use OWNERSHIP_NONE 
-	with get_action_groups(), because the GList 
-	should not be freed. Bug #31865 from 
-	Colin Law.
-
-2005-10-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Check for gtk+ 2.8. Bug #317913.
-
-2005-09-28  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/scrolledwindow.hg: get_*scrollbar_visible(): 
-	get_hscrollbar_visible() returned vscrollbar_visible() 
-	and vice-versa. Fixed. Bug #317309 by Bartek Kostrzewa.
-
-2.8.0:
-
-Updated NEWS and increased version.
-
-2.7.4:
-
-2005-08-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/dragcontext.hg: Corrected commented-out set_icon_name()
-	signature so we get it right when we can add it.
-	* gdk/src/gdk_extra.defs: Added gtk_drag_set_icon_name, copied from 
-	gtk_methods.defs.
-	* gtk/src/gtk_signals.defs.patch: Added this patch to help us 
-	modify the file after regenerating it in future.
-	* gtk/src/toolbutton.hg: Added commented-out set/get_icon_name()
- 	for use during 2.9. 
-
-2005-08-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/dragcontext.hg: Comment-out set_icon_name() with a 
-	TODO comment because it is not getting the defs defintion for 
-	some reason.
-	* gdk/src/gdk_signals.defs: Regenerated with generate_extra_defs.
-	* gtk/src/entrycompletion.hg: Properties: Correct key_length 
-	to minimum_key_length, and popup_set_widgth to popup_set_width.
-	* gtk/src/gtk_enums.defs: Removed broken gtktreeprivate.h stuff.
-	* gtk/src/gtk_other.defs: Added new FileChooser signals and 
-	properties. 
-	* gtk/src/gtk_signals.defs: Regenerated with generate_extra_defs.
-	* tools/m4/convert_gtk.m4: Added GtkFileChooserConfirmation.
-
-2005-08-17  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/src/gdk_docs.xml: Regenerated with docextract_to_xml.py.
-	* gdk/src/gdk_enums.defs: Regenerated with enums.pl.
-	* gdk/src/gdk_methods.defs: Regenerated with h2defs.py
-	* gdk/src/gdk_pixbuf.defs:  Regenerated with h2defs.py
-	* gtk/src/gtk_docs.xml: Regenerated with docextract_to_xml.py.
-	* gtk/src/gtk_enums.defs: Regenerated with enums.pl.
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py
-
-2005-08-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.ccg: unset_model(): Removed 
-	extra ; that was breaking the build.
-
-2005-08-01  Murray Cumming <murrayc@murrayc.com>
-
-	* config.h.in: Added missing undefs, needed 
-	by SUN and Tru64 compilers. Patch from 
-	The Written Word.
-
-2005-08-01  Jonner <jonathon.jongsma@gmail.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Fix the link to the 
-	Gtk::Combo reference docs, though this should talk 
-	about Gtk::ComboBox instead anyway. 
-
-2005-08-01  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/settings.ccg:
-	* gtk/src/settings.hg: Autogenerate get_default():
-	to stop it creating a second wrapper object. 
-	Bug #311311.
-
-2005-07-31  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.ccg:
-	* gtk/src/treeview.hg: Added unset_model().
-
-2.7.3:
-
-2005-07-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/pixbufloader.ccg: create_with_type():
-	Really return the created GdkPixbufLoader.
-
-2005-07-16  Ishmal  <rwjj@earthlink.net>
-
-	* gtk/src/treeviewcolumn.hg: TreeViewColumn: 
-	Use GTKMM_API to add dllspec_export and dllspec_import 
-	for MSVC++ 7.1 because it needs the extra help, even when using 
-	--export-all and auto-import. See bug #309030.
-
-2005-07-16  Murray Cumming  <murrayc@murrayc.com>
-
-	* atk/src/atk_docs.xml:
-	* gdk/src/gdk_docs.xml:
-	* gtk/src/gtk_docs.xml:
-	* gtk/src/gtk_enums.defs:
-	* gtk/src/gtk_methods.defs:
-	* pango/src/pango_docs.xml: Regenerated.
-	* gdk/src/display.hg: Added warp_pointer().
-
-2005-07-15  Murray Cumming  <murrayc@murrayc.com>
-
-	* atk/src/atk_enums.defs:
-	* gdk/src/gdk_enums.defs:
-	* pango/src/pango_enums.defs:
-	* gtk/src/gtk_enums.defs: Regenerated with 
-	glibmm/tools/enums.pl
-	* gtk/src/filechooser.hg: Added 
-	get/set_do_overwrite_confirmation() and property and signal.
-	* gtk/src/treerowreference.hg: Added get_model().
-	* gtk/src/treeview.ccg:
-	* gtk/src/treeview.hg: Added const versions of get_path_at_pos(), 
-	get_cell_area(), get_background_area(), get_visible_rect(), 
-	widget_to_tree_coords(), tree_to_widget_coords().
-	Added get_visible_range().
-	* gtk/src/treeviewcolumn.hg: Added queue_resize()
-
-2.7.2:
-
-2005-07-12  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/index.html: Remove links to useless bonobo stuff. Correct the name 
-	of the canvas link, instead of having duplicate libglademm links.
-	* gdk/src/pixbuf.ccg:
-	* gdk/src/pixbuf.hg: Add a save_to_buffer() overload without the options 
-	parameters. Added reference documentation.
-	* gtk/src/entrycompletion.hg: Remove extra ;.
-
-2.7.1:
-
-2005-07-11  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/textiter.hg: Added move_forward/backward_visible_line(s).
-
-2005-07-10  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/src/dragcontext.hg: Added set_icon(const Glib::ustring& name)
-	* gtk/src/aboutdialog.hg: Added set/get_wrap_license() and property.
-	* gtk/src/dialog.hg: Added get_response_for_widget().
-	* gtk/src/widget.hg: Added drag_source_set_icon(const Glib::ustring& icon_name).
-	* gtk/src/entrycompletion.hg: Added properties, get/set_popup_set_width(), 
-	get/set_popup_single_width().
-	* gtk/src/iconview.hg: Added get_item_at_pos(), get_visible_range(), get/set_cursor(), 
-	scroll_to_path().
-
-2005-07-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* gdk/src/gdk_methods.defs: Regenerated with h2defs.py
-	* gdk/src/cursor.ccg:
-	* gdk/src/cursor.hg: Added get_image() and 
-	a Cursor(name) constructor.
-	* gdk/src/window.hg: Added move_region()
-	* gtk/gtkmm/stock.cc:
-	* gtk/gtkmm/stock.h: Added FULLSCREEN, LEAVE_FULLSCREEN, and 
-	INFO stock items.
-	* gtk/src/gtk_methods.defs: Regenerated with h2defs.py
-	* gtk/src/image.ccg:
-	* gtk/src/image.hg: Reimplemented clear() with the new 
-	gtk_image_clear() function.
-	* gtk/src/sizegroup.hg: Added ignore_hidden property.
-	* gtk/src/window.hg: Added urgency_hint property, and 
-	get/set_urgency_hint(). Added present(timestamp) overload.
-
-2005-07-06  Claudio Saavedra  <csaavedra@alumnos.utalca.cl>
-
-	* docs/tutorial/gtkmm-tut.xml: Fixed typo in title of chapter about
-	constructors.
-
-2005-07-04  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Signals appendix: 
-	Correct ptr_fun/mem_fun typo.
-
-2005-06-09  Daniel Glöckner  <daniel-gl@gmx.net>
-
-	* tools/m4/convert_gdk.m4: Use OWNERSHIP_NONE with 
-	Glib::ListHandle< Glib::RefPtr<Device> instead of 
-	OWNERSHIP_DEEP, to avoid memory problems with 
-	Gdk::Display::list_devices().
-
-2005-05-26  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/Makefile_web.am_fragment: Use different 
-	rsync args to fix recent problem with sourceforge.
-	* docs/tutorial/gtkmm-tut.xml: Fix URL prefix for 
-	glibmm reference links.
-	* gtk/src/comboboxentry.hg: get_entry() docs: 
-	Mention Bin::get_child() instead of get_entry().
-
-2005-04-21  Alexander Nedotsukov <bland@FreeBSD.org>
-
-	* gdk/gdkmm/Makefile.am:
-	* gtk/gtkmm/Makefile.am:
-	Add inter-library dependencies, which might be 
-	needed with some versions of pkg-config.
-
-2005-05-06  Murray Cumming <murrayc@murrayc.com>
-
-	* docs/tutorial/gtkmm-tut.xml: Signals apendix, 
-	X Event signals section: Added explanation of
-	connect(slot, false);
-
-2005-05-03  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/gtkmm/comboboxentrytext.cc: 
-	* gtk/gtkmm/comboboxentrytext.h:
-	* gtk/gtkmm/comboboxtext.cc:
-	* gtk/gtkmm/comboboxtext.h:
-	Deprecated clear() in favour of new 
-	clear_items() method, because clear() exists 
-	in the base CellLayout class and is very different. 
-	Added remove_text() to remove items one at a time.
-	Added doxygen documentation comments.
-
-2005-05-03  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/cellrenderer.hg: Added the 
-	sensitive property, which was maybe new in 
-	GTK+ 2.6.
-
-2005-05-01  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/src/colormap.ccg:
-	* gdk/src/colormap.hg: Deprecated alloc_colors() and 
-	free_colors(). Add free_color() for use with 
-	alloc_color(). Bug #157744
-
-2005-04-27  Philip Langdale <plangdale@vmware.com>
-
-	* gtk/src/action.hg: 
-	Override default wrap behaviour for get_proxies to
-	use the correct ownership semantics. (bug #172892)
-
-2005-04-24  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/button.hg:
-	* gtk/src/gtk_docs_override.xml:
-	* gtk/src/image.hg:
-	* gtk/src/toolbutton.hg:
-	Documentation: Change mentions of new_from_stock() 
-	to mention the C++ constructors, and document those 
-	constructors. 
-
-2005-04-22  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/cellrenderer.hg: Add documentation 
-	saying that signal_editing_started() does not 
-	work, so use the C API.
-	* gtk/src/combobox.hg: Added TODO comment 
-	for a future ABI break.
-
-2005-04-19  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.in:
-	* examples/book/Makefile.am:
-	* examples/book/comboboxentry/.cvsignore:
-	* examples/book/comboboxentry/Makefile.am:
-	* examples/book/comboboxentry/complex/.cvsignore:
-	* examples/book/comboboxentry/complex/Makefile.am:
-	* examples/book/comboboxentry/complex/examplewindow.cc:
-	* examples/book/comboboxentry/complex/examplewindow.h:
-	* examples/book/comboboxentry/complex/main.cc:
-	* examples/book/comboboxentry/text/.cvsignore:
-	* examples/book/comboboxentry/text/Makefile.am:
-	* examples/book/comboboxentry/text/examplewindow.cc:
-	* examples/book/comboboxentry/text/examplewindow.h:
-	* examples/book/comboboxentry/text/main.cc:
-        Added ComboBoxEntry and ComboBoxEntryText examples, 
-	based on the existing ComboBox and ComboBoxText 
-	examples.
-
-2005-04-15  Murray Cumming  <murrayc@murrayc.com>
-
-	* examples/book/menus_and_toolbars/Makefile.am:
-	* examples/book/menus_and_toolbars/rain.png:
-	Add missing rain.png file and distribute it.
-	* examples/book/menus_and_toolbars/examplewindow.cc:
-	Catch the exception if the pixbuf file is not found.
-
-2005-04-07  Murray Cumming <murrayc@murrayc.com>
-
-	* gdk/src/display.hg:
-	* gdk/src/displaymanager.hg:
-	* gdk/src/pixbufloader.hg:
-	* gdk/src/screen.hg:
-	* gtk/src/accelgroup.hg:
-	* gtk/src/action.hg:
-	* gtk/src/actiongroup.hg:
-	* gtk/src/cellrenderer.hg:
-	* gtk/src/cellrenderertoggle.hg:
-	* gtk/src/colorbutton.hg:
-	* gtk/src/combobox.hg:
-	* gtk/src/entrycompletion.hg:
-	* gtk/src/filechooser.hg:
-	* gtk/src/fontbutton.hg:
-	* gtk/src/radioaction.hg:
-	* gtk/src/radiomenuitem.hg:
-	* gtk/src/range.hg:
-	* gtk/src/textbuffer.hg:
-	* gtk/src/togglebutton.hg:
-	* gtk/src/toolbar.hg:
-	* gtk/src/toolbutton.hg:
-	* gtk/src/toolitem.hg:
-	* gtk/src/treeiter.hg:
-	* gtk/src/uimanager.hg:
-	* gtk/src/widget.hg:
-	Added doxygen documentation for signals, based on 
-	the C documentation (in the .c files) where that 
-	documentation exists.
-
-2005-04-07  Murray Cumming <murrayc@murrayc.com>
-
-	* gtk/src/treeview.ccg:
-	* gtk/src/treeview.hg: Rename 
-	TreeView::_auto_store_on_cellrenderer_toggle_edited() to 
-	TreeView::_auto_store_on_cellrenderer_toggle_edited_with_model()
-	and add back the old _auto_store_on_cellrenderer_toggle_edited(), 
-	so that it still exists for apps built with the old templates. 
-	This is the only non-template code that was changed in the 
-	previous commit.
-
-2005-04-06  Murray Cumming  <murrayc@murrayc.com>
-
-	* gtk/src/treeview.[hg|ccg]: append_*_(): Pass the model to the 
-	private helper template functions, instead of the treeview, to 
-	prevent the warning when closing the window while editing a cell.
-	Bug #170855.
-
-This is the HEAD branch. The stable branch is gtkmm-2-6. 
-
-2005-03-19  Murray Cumming <murrayc@murrayc.com>
-
-	* demos/gtk-demo/example_treeview_editable_cells.cc:
-	* gtk/src/treeview.ccg:
-	* gtk/src/treeview.hg:
-	Test the result of _get_model_base() for a null refptr,
-	to help avoid a crash when closing a window while the 
-	cell renderer is in edit mode. Bug #170855.
-
-2005-03-17  Claudio Saavedra <csaavedra@alumnos.utalca.cl>
-
-	* docs/tutorial/gtkmm-tut.xml: Fixes typo in #170730. Pointed out 
-	by Jacek Wotka.
-
 2.6.1:
 
 2005-03-12  Claudio Saavedra <csaavedra@alumnos.utalca.cl>
diff --git a/libs/gtkmm2/atk/atkmm/action.cc b/libs/gtkmm2/atk/atkmm/action.cc
index 9af6fe0e85..69a260463c 100644
--- a/libs/gtkmm2/atk/atkmm/action.cc
+++ b/libs/gtkmm2/atk/atkmm/action.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/action.h>
 #include <atkmm/private/action_p.h>
 
@@ -73,20 +72,14 @@ void Action_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->do_action = &do_action_vfunc_callback;
   klass->get_n_actions = &get_n_actions_vfunc_callback;
   klass->get_description = &get_description_vfunc_callback;
   klass->get_name = &get_name_vfunc_callback;
   klass->get_keybinding = &get_keybinding_vfunc_callback;
   klass->set_description = &set_description_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gboolean Action_Class::do_action_vfunc_callback(AtkAction* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -99,20 +92,16 @@ gboolean Action_Class::do_action_vfunc_callback(AtkAction* self, gint i)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->do_action_vfunc(i
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -129,6 +118,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gint Action_Class::get_n_actions_vfunc_callback(AtkAction* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -141,19 +131,15 @@ gint Action_Class::get_n_actions_vfunc_callback(AtkAction* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_actions_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -170,6 +156,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 const gchar* Action_Class::get_description_vfunc_callback(AtkAction* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -182,20 +169,16 @@ const gchar* Action_Class::get_description_vfunc_callback(AtkAction* self, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_description_vfunc(i
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -212,6 +195,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 const gchar* Action_Class::get_name_vfunc_callback(AtkAction* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -224,20 +208,16 @@ const gchar* Action_Class::get_name_vfunc_callback(AtkAction* self, gint i)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_name_vfunc(i
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -254,6 +234,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 const gchar* Action_Class::get_keybinding_vfunc_callback(AtkAction* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -266,20 +247,16 @@ const gchar* Action_Class::get_keybinding_vfunc_callback(AtkAction* self, gint i
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_keybinding_vfunc(i
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -296,6 +273,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 gboolean Action_Class::set_description_vfunc_callback(AtkAction* self, gint i, const gchar* desc)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -308,21 +286,17 @@ gboolean Action_Class::set_description_vfunc_callback(AtkAction* self, gint i, c
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_description_vfunc(i
 , Glib::convert_const_gchar_ptr_to_ustring(desc)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -339,10 +313,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Action_Class::wrap_new(GObject* object)
@@ -421,10 +391,6 @@ Glib::ustring Action::get_localized_name(int i)
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 bool Atk::Action::do_action_vfunc(int i) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -438,6 +404,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 int Atk::Action::get_n_actions_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -451,6 +418,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 const char* Atk::Action::get_description_vfunc(int i) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -464,6 +432,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const char* RType;
   return RType();
 }
+
 const char* Atk::Action::get_name_vfunc(int i) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -477,6 +446,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const char* RType;
   return RType();
 }
+
 const char* Atk::Action::get_keybinding_vfunc(int i) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -490,6 +460,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const char* RType;
   return RType();
 }
+
 bool Atk::Action::set_description_vfunc(int i, const Glib::ustring& desc) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -503,7 +474,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/action.h b/libs/gtkmm2/atk/atkmm/action.h
index c31a2c9e31..af8a131378 100644
--- a/libs/gtkmm2/atk/atkmm/action.h
+++ b/libs/gtkmm2/atk/atkmm/action.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_ACTION_H
 #define _ATKMM_ACTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -155,46 +154,23 @@ public:
   Glib::ustring get_localized_name(int i);
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool do_action_vfunc(int i);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_actions_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const char* get_description_vfunc(int i) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const char* get_name_vfunc(int i) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const char* get_keybinding_vfunc(int i) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_description_vfunc(int i, const Glib::ustring& desc);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual bool do_action_vfunc(int i);
+    virtual int get_n_actions_vfunc() const;
+    virtual const char* get_description_vfunc(int i) const;
+    virtual const char* get_name_vfunc(int i) const;
+    virtual const char* get_keybinding_vfunc(int i) const;
+    virtual bool set_description_vfunc(int i, const Glib::ustring& desc);
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -213,6 +189,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_ACTION_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/component.cc b/libs/gtkmm2/atk/atkmm/component.cc
index 8d51116bc1..c4256e7699 100644
--- a/libs/gtkmm2/atk/atkmm/component.cc
+++ b/libs/gtkmm2/atk/atkmm/component.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/component.h>
 #include <atkmm/private/component_p.h>
 
@@ -87,7 +86,6 @@ void Component_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->add_focus_handler = &add_focus_handler_vfunc_callback;
   klass->contains = &contains_vfunc_callback;
   klass->ref_accessible_at_point = &ref_accessible_at_point_vfunc_callback;
@@ -101,13 +99,8 @@ void Component_Class::iface_init_function(void* g_iface, void*)
   klass->set_extents = &set_extents_vfunc_callback;
   klass->set_position = &set_position_vfunc_callback;
   klass->set_size = &set_size_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 guint Component_Class::add_focus_handler_vfunc_callback(AtkComponent* self, AtkFocusHandler handler)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -120,19 +113,15 @@ guint Component_Class::add_focus_handler_vfunc_callback(AtkComponent* self, AtkF
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->add_focus_handler_vfunc(handler);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -149,6 +138,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef guint RType;
   return RType();
 }
+
 gboolean Component_Class::contains_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -161,22 +151,18 @@ gboolean Component_Class::contains_vfunc_callback(AtkComponent* self, gint x, gi
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->contains_vfunc(x
 , y
 , ((CoordType)(coord_type))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -193,6 +179,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 AtkObject* Component_Class::ref_accessible_at_point_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -205,22 +192,18 @@ AtkObject* Component_Class::ref_accessible_at_point_vfunc_callback(AtkComponent*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap_copy(obj->get_accessible_at_point_vfunc(x
 , y
 , ((CoordType)(coord_type))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -237,6 +220,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
+
 void Component_Class::get_extents_vfunc_callback(AtkComponent* self, gint* x, gint* y, gint* width, gint* height, AtkCoordType coord_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -249,10 +233,8 @@ void Component_Class::get_extents_vfunc_callback(AtkComponent* self, gint* x, gi
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_extents_vfunc(*(x)
 , *(y)
@@ -260,13 +242,11 @@ void Component_Class::get_extents_vfunc_callback(AtkComponent* self, gint* x, gi
 , *(height)
 , ((CoordType)(coord_type))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -280,6 +260,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_extents)(self, x, y, width, height, coord_type);
   }
 }
+
 void Component_Class::get_position_vfunc_callback(AtkComponent* self, gint* x, gint* y, AtkCoordType coord_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -292,22 +273,18 @@ void Component_Class::get_position_vfunc_callback(AtkComponent* self, gint* x, g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_position_vfunc(*(x)
 , *(y)
 , ((CoordType)(coord_type))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -321,6 +298,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_position)(self, x, y, coord_type);
   }
 }
+
 void Component_Class::get_size_vfunc_callback(AtkComponent* self, gint* width, gint* height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -333,21 +311,17 @@ void Component_Class::get_size_vfunc_callback(AtkComponent* self, gint* width, g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_size_vfunc(*(width)
 , *(height)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -361,6 +335,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_size)(self, width, height);
   }
 }
+
 AtkLayer Component_Class::get_layer_vfunc_callback(AtkComponent* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -373,19 +348,15 @@ AtkLayer Component_Class::get_layer_vfunc_callback(AtkComponent* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return ((AtkLayer)(obj->get_layer_vfunc()));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -402,6 +373,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkLayer RType;
   return RType();
 }
+
 gint Component_Class::get_mdi_zorder_vfunc_callback(AtkComponent* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -414,19 +386,15 @@ gint Component_Class::get_mdi_zorder_vfunc_callback(AtkComponent* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_mdi_zorder_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -443,6 +411,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gboolean Component_Class::grab_focus_vfunc_callback(AtkComponent* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -455,19 +424,15 @@ gboolean Component_Class::grab_focus_vfunc_callback(AtkComponent* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->grab_focus_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -484,6 +449,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 void Component_Class::remove_focus_handler_vfunc_callback(AtkComponent* self, guint handler_id)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -496,19 +462,15 @@ void Component_Class::remove_focus_handler_vfunc_callback(AtkComponent* self, gu
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->remove_focus_handler_vfunc(handler_id);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -522,6 +484,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->remove_focus_handler)(self, handler_id);
   }
 }
+
 gboolean Component_Class::set_extents_vfunc_callback(AtkComponent* self, gint x, gint y, gint width, gint height, AtkCoordType coord_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -534,10 +497,8 @@ gboolean Component_Class::set_extents_vfunc_callback(AtkComponent* self, gint x,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_extents_vfunc(x
 , y
@@ -545,13 +506,11 @@ gboolean Component_Class::set_extents_vfunc_callback(AtkComponent* self, gint x,
 , height
 , ((CoordType)(coord_type))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -568,6 +527,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Component_Class::set_position_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -580,22 +540,18 @@ gboolean Component_Class::set_position_vfunc_callback(AtkComponent* self, gint x
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_position_vfunc(x
 , y
 , ((CoordType)(coord_type))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -612,6 +568,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Component_Class::set_size_vfunc_callback(AtkComponent* self, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -624,21 +581,17 @@ gboolean Component_Class::set_size_vfunc_callback(AtkComponent* self, gint width
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_size_vfunc(width
 , height
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -655,10 +608,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Component_Class::wrap_new(GObject* object)
@@ -718,17 +667,17 @@ Glib::RefPtr<Atk::Object> Component::get_accessible_at_point(int x, int y, Coord
 
 void Component::get_extents(int& x, int& y, int& width, int& height, CoordType coord_type) const
 {
-atk_component_get_extents(const_cast<AtkComponent*>(gobj()), &x, &y, &width, &height, ((AtkCoordType)(coord_type))); 
+  atk_component_get_extents(const_cast<AtkComponent*>(gobj()), &x, &y, &width, &height, ((AtkCoordType)(coord_type)));
 }
 
 void Component::get_position(int& x, int& y, CoordType coord_type) const
 {
-atk_component_get_position(const_cast<AtkComponent*>(gobj()), &x, &y, ((AtkCoordType)(coord_type))); 
+  atk_component_get_position(const_cast<AtkComponent*>(gobj()), &x, &y, ((AtkCoordType)(coord_type)));
 }
 
 void Component::get_size(int& width, int& height) const
 {
-atk_component_get_size(const_cast<AtkComponent*>(gobj()), &width, &height); 
+  atk_component_get_size(const_cast<AtkComponent*>(gobj()), &width, &height);
 }
 
 Layer Component::get_layer() const
@@ -748,7 +697,7 @@ bool Component::grab_focus()
 
 void Component::remove_focus_handler(guint handler_id)
 {
-atk_component_remove_focus_handler(gobj(), handler_id); 
+  atk_component_remove_focus_handler(gobj(), handler_id);
 }
 
 bool Component::set_extents(int x, int y, int width, int height, CoordType coord_type)
@@ -767,10 +716,6 @@ bool Component::set_size(int width, int height)
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 guint Atk::Component::add_focus_handler_vfunc(AtkFocusHandler handler) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -784,6 +729,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef guint RType;
   return RType();
 }
+
 bool Atk::Component::contains_vfunc(int x, int y, CoordType coord_type) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -797,6 +743,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 Glib::RefPtr<Atk::Object> Atk::Component::get_accessible_at_point_vfunc(int x, int y, CoordType coord_type) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -810,6 +757,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 void Atk::Component::get_extents_vfunc(int& x, int& y, int& width, int& height, CoordType coord_type) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -820,6 +768,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_extents)
     (*base->get_extents)(const_cast<AtkComponent*>(gobj()),&x,&y,&width,&height,((AtkCoordType)(coord_type)));
 }
+
 void Atk::Component::get_position_vfunc(int& x, int& y, CoordType coord_type) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -830,6 +779,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_position)
     (*base->get_position)(const_cast<AtkComponent*>(gobj()),&x,&y,((AtkCoordType)(coord_type)));
 }
+
 void Atk::Component::get_size_vfunc(int& width, int& height) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -840,6 +790,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_size)
     (*base->get_size)(const_cast<AtkComponent*>(gobj()),&width,&height);
 }
+
 Layer Atk::Component::get_layer_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -853,6 +804,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Layer RType;
   return RType();
 }
+
 int Atk::Component::get_mdi_zorder_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -866,6 +818,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 bool Atk::Component::grab_focus_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -879,6 +832,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 void Atk::Component::remove_focus_handler_vfunc(guint handler_id) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -889,6 +843,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->remove_focus_handler)
     (*base->remove_focus_handler)(gobj(),handler_id);
 }
+
 bool Atk::Component::set_extents_vfunc(int x, int y, int width, int height, CoordType coord_type) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -902,6 +857,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Component::set_position_vfunc(int x, int y, CoordType coord_type) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -915,6 +871,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Component::set_size_vfunc(int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -928,7 +885,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/component.h b/libs/gtkmm2/atk/atkmm/component.h
index ccde1fb22d..889d626dae 100644
--- a/libs/gtkmm2/atk/atkmm/component.h
+++ b/libs/gtkmm2/atk/atkmm/component.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_COMPONENT_H
 #define _ATKMM_COMPONENT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -284,76 +283,32 @@ public:
   bool set_size(int width, int height);
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual guint add_focus_handler_vfunc(AtkFocusHandler handler);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool contains_vfunc(int x, int y, CoordType coord_type) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_accessible_at_point_vfunc(int x, int y, CoordType coord_type);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_extents_vfunc(int& x, int& y, int& width, int& height, CoordType coord_type) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_position_vfunc(int& x, int& y, CoordType coord_type) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual guint add_focus_handler_vfunc(AtkFocusHandler handler);
+    virtual bool contains_vfunc(int x, int y, CoordType coord_type) const;
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_size_vfunc(int& width, int& height) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual Glib::RefPtr<Atk::Object> get_accessible_at_point_vfunc(int x, int y, CoordType coord_type);
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Layer get_layer_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_mdi_zorder_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool grab_focus_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void remove_focus_handler_vfunc(guint handler_id);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_extents_vfunc(int x, int y, int width, int height, CoordType coord_type);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_position_vfunc(int x, int y, CoordType coord_type);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_size_vfunc(int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void get_extents_vfunc(int& x, int& y, int& width, int& height, CoordType coord_type) const;
+    virtual void get_position_vfunc(int& x, int& y, CoordType coord_type) const;
+    virtual void get_size_vfunc(int& width, int& height) const;
+    virtual Layer get_layer_vfunc() const;
+    virtual int get_mdi_zorder_vfunc() const;
+    virtual bool grab_focus_vfunc();
+    virtual void remove_focus_handler_vfunc(guint handler_id);
+    virtual bool set_extents_vfunc(int x, int y, int width, int height, CoordType coord_type);
+    virtual bool set_position_vfunc(int x, int y, CoordType coord_type);
+    virtual bool set_size_vfunc(int width, int height);
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -372,6 +327,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_COMPONENT_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/document.cc b/libs/gtkmm2/atk/atkmm/document.cc
index f27b4ff522..64946c6f84 100644
--- a/libs/gtkmm2/atk/atkmm/document.cc
+++ b/libs/gtkmm2/atk/atkmm/document.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/document.h>
 #include <atkmm/private/document_p.h>
 
@@ -81,16 +80,10 @@ void Document_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_document_type = &get_document_type_vfunc_callback;
   klass->get_document = &get_document_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 const gchar* Document_Class::get_document_type_vfunc_callback(AtkDocument* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -103,19 +96,15 @@ const gchar* Document_Class::get_document_type_vfunc_callback(AtkDocument* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_document_type_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -132,6 +121,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 gpointer Document_Class::get_document_vfunc_callback(AtkDocument* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -144,19 +134,15 @@ gpointer Document_Class::get_document_vfunc_callback(AtkDocument* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_document_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -173,10 +159,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gpointer RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Document_Class::wrap_new(GObject* object)
@@ -230,10 +212,6 @@ gpointer Document::get_document()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 const gchar* Atk::Document::get_document_type_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -247,6 +225,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const gchar* RType;
   return RType();
 }
+
 gpointer Atk::Document::get_document_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -260,7 +239,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef gpointer RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/document.h b/libs/gtkmm2/atk/atkmm/document.h
index 76c84a4007..71808475c3 100644
--- a/libs/gtkmm2/atk/atkmm/document.h
+++ b/libs/gtkmm2/atk/atkmm/document.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_DOCUMENT_H
 #define _ATKMM_DOCUMENT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -111,30 +110,19 @@ public:
   gpointer get_document();
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const gchar* get_document_type_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual gpointer get_document_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual const gchar* get_document_type_vfunc();
+    virtual gpointer get_document_vfunc() const;
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -153,6 +141,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_DOCUMENT_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/editabletext.cc b/libs/gtkmm2/atk/atkmm/editabletext.cc
index eb776c954c..10e58003b7 100644
--- a/libs/gtkmm2/atk/atkmm/editabletext.cc
+++ b/libs/gtkmm2/atk/atkmm/editabletext.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/editabletext.h>
 #include <atkmm/private/editabletext_p.h>
 
@@ -74,7 +73,6 @@ void EditableText_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->set_run_attributes = &set_run_attributes_vfunc_callback;
   klass->set_text_contents = &set_text_contents_vfunc_callback;
   klass->insert_text = &insert_text_vfunc_callback;
@@ -82,13 +80,8 @@ void EditableText_Class::iface_init_function(void* g_iface, void*)
   klass->cut_text = &cut_text_vfunc_callback;
   klass->delete_text = &delete_text_vfunc_callback;
   klass->paste_text = &paste_text_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gboolean EditableText_Class::set_run_attributes_vfunc_callback(AtkEditableText* self, AtkAttributeSet* attrib_set, gint start_offset, gint end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -101,21 +94,17 @@ gboolean EditableText_Class::set_run_attributes_vfunc_callback(AtkEditableText*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_run_attributes_vfunc(attrib_set, start_offset
 , end_offset
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -132,6 +121,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 void EditableText_Class::set_text_contents_vfunc_callback(AtkEditableText* self, const gchar* string)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -144,20 +134,16 @@ void EditableText_Class::set_text_contents_vfunc_callback(AtkEditableText* self,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_text_contents_vfunc(Glib::convert_const_gchar_ptr_to_ustring(string)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -171,6 +157,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_text_contents)(self, string);
   }
 }
+
 void EditableText_Class::insert_text_vfunc_callback(AtkEditableText* self, const gchar* string, gint length, gint* position)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -183,22 +170,18 @@ void EditableText_Class::insert_text_vfunc_callback(AtkEditableText* self, const
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->insert_text_vfunc(Glib::convert_const_gchar_ptr_to_ustring(string)
 , length
 , *(position)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -212,6 +195,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->insert_text)(self, string, length, position);
   }
 }
+
 void EditableText_Class::copy_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -224,21 +208,17 @@ void EditableText_Class::copy_text_vfunc_callback(AtkEditableText* self, gint st
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->copy_text_vfunc(start_pos
 , end_pos
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -252,6 +232,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->copy_text)(self, start_pos, end_pos);
   }
 }
+
 void EditableText_Class::cut_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -264,21 +245,17 @@ void EditableText_Class::cut_text_vfunc_callback(AtkEditableText* self, gint sta
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->cut_text_vfunc(start_pos
 , end_pos
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -292,6 +269,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->cut_text)(self, start_pos, end_pos);
   }
 }
+
 void EditableText_Class::delete_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -304,21 +282,17 @@ void EditableText_Class::delete_text_vfunc_callback(AtkEditableText* self, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->delete_text_vfunc(start_pos
 , end_pos
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -332,6 +306,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->delete_text)(self, start_pos, end_pos);
   }
 }
+
 void EditableText_Class::paste_text_vfunc_callback(AtkEditableText* self, gint position)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -344,20 +319,16 @@ void EditableText_Class::paste_text_vfunc_callback(AtkEditableText* self, gint p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->paste_text_vfunc(position
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -371,10 +342,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->paste_text)(self, position);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* EditableText_Class::wrap_new(GObject* object)
@@ -424,39 +391,35 @@ bool EditableText::set_run_attributes(const AttributeSet& attrib_set, int start_
 
 void EditableText::set_text_contents(const Glib::ustring& string)
 {
-atk_editable_text_set_text_contents(gobj(), string.c_str()); 
+  atk_editable_text_set_text_contents(gobj(), string.c_str());
 }
 
 void EditableText::insert_text(const Glib::ustring& string, int length, int& position)
 {
-atk_editable_text_insert_text(gobj(), string.c_str(), length, &position); 
+  atk_editable_text_insert_text(gobj(), string.c_str(), length, &position);
 }
 
 void EditableText::copy_text(int start_pos, int end_pos)
 {
-atk_editable_text_copy_text(gobj(), start_pos, end_pos); 
+  atk_editable_text_copy_text(gobj(), start_pos, end_pos);
 }
 
 void EditableText::cut_text(int start_pos, int end_pos)
 {
-atk_editable_text_cut_text(gobj(), start_pos, end_pos); 
+  atk_editable_text_cut_text(gobj(), start_pos, end_pos);
 }
 
 void EditableText::delete_text(int start_pos, int end_pos)
 {
-atk_editable_text_delete_text(gobj(), start_pos, end_pos); 
+  atk_editable_text_delete_text(gobj(), start_pos, end_pos);
 }
 
 void EditableText::paste_text(int position)
 {
-atk_editable_text_paste_text(gobj(), position); 
+  atk_editable_text_paste_text(gobj(), position);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 bool Atk::EditableText::set_run_attributes_vfunc(AtkAttributeSet* attrib_set, int start_offset, int end_offset) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -470,6 +433,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 void Atk::EditableText::set_text_contents_vfunc(const Glib::ustring& string) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -480,6 +444,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_text_contents)
     (*base->set_text_contents)(gobj(),string.c_str());
 }
+
 void Atk::EditableText::insert_text_vfunc(const Glib::ustring& string, int length, int& position) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -490,6 +455,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->insert_text)
     (*base->insert_text)(gobj(),string.c_str(),length,&position);
 }
+
 void Atk::EditableText::copy_text_vfunc(int start_pos, int end_pos) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -500,6 +466,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->copy_text)
     (*base->copy_text)(gobj(),start_pos,end_pos);
 }
+
 void Atk::EditableText::cut_text_vfunc(int start_pos, int end_pos) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -510,6 +477,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->cut_text)
     (*base->cut_text)(gobj(),start_pos,end_pos);
 }
+
 void Atk::EditableText::delete_text_vfunc(int start_pos, int end_pos) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -520,6 +488,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->delete_text)
     (*base->delete_text)(gobj(),start_pos,end_pos);
 }
+
 void Atk::EditableText::paste_text_vfunc(int position) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -530,7 +499,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->paste_text)
     (*base->paste_text)(gobj(),position);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/editabletext.h b/libs/gtkmm2/atk/atkmm/editabletext.h
index 982673231c..233aa9e892 100644
--- a/libs/gtkmm2/atk/atkmm/editabletext.h
+++ b/libs/gtkmm2/atk/atkmm/editabletext.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_EDITABLETEXT_H
 #define _ATKMM_EDITABLETEXT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -154,50 +153,24 @@ public:
   void paste_text(int position);
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_run_attributes_vfunc(AtkAttributeSet* attrib_set, int start_offset, int end_offset);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_text_contents_vfunc(const Glib::ustring& string);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void insert_text_vfunc(const Glib::ustring& string, int length, int& position);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void copy_text_vfunc(int start_pos, int end_pos);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void cut_text_vfunc(int start_pos, int end_pos);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void delete_text_vfunc(int start_pos, int end_pos);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void paste_text_vfunc(int position);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual bool set_run_attributes_vfunc(AtkAttributeSet* attrib_set, int start_offset, int end_offset);
+    virtual void set_text_contents_vfunc(const Glib::ustring& string);
+    virtual void insert_text_vfunc(const Glib::ustring& string, int length, int& position);
+    virtual void copy_text_vfunc(int start_pos, int end_pos);
+    virtual void cut_text_vfunc(int start_pos, int end_pos);
+    virtual void delete_text_vfunc(int start_pos, int end_pos);
+    virtual void paste_text_vfunc(int position);
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -216,6 +189,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_EDITABLETEXT_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/hyperlink.cc b/libs/gtkmm2/atk/atkmm/hyperlink.cc
index 3bbf41c426..d9e1050a7b 100644
--- a/libs/gtkmm2/atk/atkmm/hyperlink.cc
+++ b/libs/gtkmm2/atk/atkmm/hyperlink.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/hyperlink.h>
 #include <atkmm/private/hyperlink_p.h>
 
@@ -38,15 +37,13 @@ namespace Atk
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Hyperlink_signal_link_activated_info =
+const Glib::SignalProxyInfo Hyperlink_signal_link_activated_info =
 {
   "link_activated",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -94,7 +91,6 @@ void Hyperlink_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_uri = &get_uri_vfunc_callback;
   klass->get_object = &get_object_vfunc_callback;
   klass->get_end_index = &get_end_index_vfunc_callback;
@@ -103,14 +99,9 @@ void Hyperlink_Class::class_init_function(void* g_class, void* class_data)
   klass->get_n_anchors = &get_n_anchors_vfunc_callback;
   klass->link_state = &link_state_vfunc_callback;
   klass->is_selected_link = &is_selected_link_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->link_activated = &link_activated_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gchar* Hyperlink_Class::get_uri_vfunc_callback(AtkHyperlink* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -123,20 +114,16 @@ gchar* Hyperlink_Class::get_uri_vfunc_callback(AtkHyperlink* self, gint i)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_uri_vfunc(i
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -152,6 +139,7 @@ gchar* Hyperlink_Class::get_uri_vfunc_callback(AtkHyperlink* self, gint i)
   typedef gchar* RType;
   return RType();
 }
+
 AtkObject* Hyperlink_Class::get_object_vfunc_callback(AtkHyperlink* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -164,20 +152,16 @@ AtkObject* Hyperlink_Class::get_object_vfunc_callback(AtkHyperlink* self, gint i
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->get_object_vfunc(i
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -193,6 +177,7 @@ AtkObject* Hyperlink_Class::get_object_vfunc_callback(AtkHyperlink* self, gint i
   typedef AtkObject* RType;
   return RType();
 }
+
 gint Hyperlink_Class::get_end_index_vfunc_callback(AtkHyperlink* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -205,19 +190,15 @@ gint Hyperlink_Class::get_end_index_vfunc_callback(AtkHyperlink* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_end_index_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -233,6 +214,7 @@ gint Hyperlink_Class::get_end_index_vfunc_callback(AtkHyperlink* self)
   typedef gint RType;
   return RType();
 }
+
 gint Hyperlink_Class::get_start_index_vfunc_callback(AtkHyperlink* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -245,19 +227,15 @@ gint Hyperlink_Class::get_start_index_vfunc_callback(AtkHyperlink* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_start_index_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -273,6 +251,7 @@ gint Hyperlink_Class::get_start_index_vfunc_callback(AtkHyperlink* self)
   typedef gint RType;
   return RType();
 }
+
 gboolean Hyperlink_Class::is_valid_vfunc_callback(AtkHyperlink* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -285,19 +264,15 @@ gboolean Hyperlink_Class::is_valid_vfunc_callback(AtkHyperlink* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->is_valid_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -313,6 +288,7 @@ gboolean Hyperlink_Class::is_valid_vfunc_callback(AtkHyperlink* self)
   typedef gboolean RType;
   return RType();
 }
+
 gint Hyperlink_Class::get_n_anchors_vfunc_callback(AtkHyperlink* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -325,19 +301,15 @@ gint Hyperlink_Class::get_n_anchors_vfunc_callback(AtkHyperlink* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_anchors_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -353,6 +325,7 @@ gint Hyperlink_Class::get_n_anchors_vfunc_callback(AtkHyperlink* self)
   typedef gint RType;
   return RType();
 }
+
 guint Hyperlink_Class::link_state_vfunc_callback(AtkHyperlink* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -365,19 +338,15 @@ guint Hyperlink_Class::link_state_vfunc_callback(AtkHyperlink* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->link_state_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -393,6 +362,7 @@ guint Hyperlink_Class::link_state_vfunc_callback(AtkHyperlink* self)
   typedef guint RType;
   return RType();
 }
+
 gboolean Hyperlink_Class::is_selected_link_vfunc_callback(AtkHyperlink* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -405,19 +375,15 @@ gboolean Hyperlink_Class::is_selected_link_vfunc_callback(AtkHyperlink* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->is_selected_link_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -433,9 +399,8 @@ gboolean Hyperlink_Class::is_selected_link_vfunc_callback(AtkHyperlink* self)
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Hyperlink_Class::link_activated_callback(AtkHyperlink* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -448,19 +413,15 @@ void Hyperlink_Class::link_activated_callback(AtkHyperlink* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_link_activated();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -473,7 +434,6 @@ void Hyperlink_Class::link_activated_callback(AtkHyperlink* self)
       (*base->link_activated)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Hyperlink_Class::wrap_new(GObject* object)
@@ -526,15 +486,20 @@ Glib::RefPtr<Atk::Object> Hyperlink::get_object(int i)
 {
 
   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_hyperlink_get_object(gobj(), i));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Atk::Object> Hyperlink::get_object(int i) const
 {
-  return const_cast<Hyperlink*>(this)->get_object(i);
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_hyperlink_get_object(const_cast<AtkHyperlink*>(gobj()), i));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 int Hyperlink::get_end_index() const
@@ -574,36 +539,27 @@ Glib::SignalProxy0< void > Hyperlink::signal_link_activated()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Hyperlink::property_selected_link() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "selected-link");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_number_of_anchors() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "number-of-anchors");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_end_index() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "end-index");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Hyperlink::property_start_index() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "start-index");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Atk::Hyperlink::on_link_activated()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -613,9 +569,8 @@ void Atk::Hyperlink::on_link_activated()
   if(base && base->link_activated)
     (*base->link_activated)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 gchar* Atk::Hyperlink::get_uri_vfunc(int i) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -628,6 +583,7 @@ gchar* Atk::Hyperlink::get_uri_vfunc(int i) const
   typedef gchar* RType;
   return RType();
 }
+
 Glib::RefPtr<Atk::Object> Atk::Hyperlink::get_object_vfunc(int i) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -640,6 +596,7 @@ Glib::RefPtr<Atk::Object> Atk::Hyperlink::get_object_vfunc(int i)
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 int Atk::Hyperlink::get_end_index_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -652,6 +609,7 @@ int Atk::Hyperlink::get_end_index_vfunc() const
   typedef int RType;
   return RType();
 }
+
 int Atk::Hyperlink::get_start_index_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -664,6 +622,7 @@ int Atk::Hyperlink::get_start_index_vfunc() const
   typedef int RType;
   return RType();
 }
+
 bool Atk::Hyperlink::is_valid_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -676,6 +635,7 @@ bool Atk::Hyperlink::is_valid_vfunc() const
   typedef bool RType;
   return RType();
 }
+
 int Atk::Hyperlink::get_n_anchors_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -688,6 +648,7 @@ int Atk::Hyperlink::get_n_anchors_vfunc() const
   typedef int RType;
   return RType();
 }
+
 guint Atk::Hyperlink::link_state_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -700,6 +661,7 @@ guint Atk::Hyperlink::link_state_vfunc() const
   typedef guint RType;
   return RType();
 }
+
 bool Atk::Hyperlink::is_selected_link_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -712,7 +674,6 @@ bool Atk::Hyperlink::is_selected_link_vfunc() const
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/hyperlink.h b/libs/gtkmm2/atk/atkmm/hyperlink.h
index 5a529ec46b..293137afb0 100644
--- a/libs/gtkmm2/atk/atkmm/hyperlink.h
+++ b/libs/gtkmm2/atk/atkmm/hyperlink.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_HYPERLINK_H
 #define _ATKMM_HYPERLINK_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -171,108 +170,66 @@ public:
   bool is_selected_link() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %link_activated()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_link_activated();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Specifies whether the AtkHyperlink object is selected.
+  /** Specifies whether the AtkHyperlink object is selected.
    *
    * 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_selected_link() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of anchors associated with the AtkHyperlink object.
+  /** The number of anchors associated with the AtkHyperlink object.
    *
    * 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_number_of_anchors() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The end index of the AtkHyperlink object.
+  /** The end index of the AtkHyperlink object.
    *
    * 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_end_index() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The start index of the AtkHyperlink object.
+  /** The start index of the AtkHyperlink object.
    *
    * 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_start_index() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual gchar* get_uri_vfunc(int i) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_object_vfunc(int i);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_end_index_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_start_index_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool is_valid_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_anchors_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual guint link_state_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual gchar* get_uri_vfunc(int i) const;
+    virtual Glib::RefPtr<Atk::Object> get_object_vfunc(int i);
+    virtual int get_end_index_vfunc() const;
+    virtual int get_start_index_vfunc() const;
+    virtual bool is_valid_vfunc() const;
+    virtual int get_n_anchors_vfunc() const;
+    virtual guint link_state_vfunc() const;
+    virtual bool is_selected_link_vfunc() const; 
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool is_selected_link_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
- 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_link_activated();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/atk/atkmm/hypertext.cc b/libs/gtkmm2/atk/atkmm/hypertext.cc
index c0e2781cd2..f383ba5e74 100644
--- a/libs/gtkmm2/atk/atkmm/hypertext.cc
+++ b/libs/gtkmm2/atk/atkmm/hypertext.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/hypertext.h>
 #include <atkmm/private/hypertext_p.h>
 
@@ -38,8 +37,7 @@ namespace Atk
 namespace
 {
 
-
-static void Hypertext_signal_link_selected_callback(AtkHypertext* self, gint p0,void* data)
+void Hypertext_signal_link_selected_callback(AtkHypertext* self, gint p0,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,int > SlotType;
@@ -47,31 +45,26 @@ static void Hypertext_signal_link_selected_callback(AtkHypertext* self, gint p0,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Hypertext_signal_link_selected_info =
+const Glib::SignalProxyInfo Hypertext_signal_link_selected_info =
 {
   "link_selected",
   (GCallback) &Hypertext_signal_link_selected_callback,
   (GCallback) &Hypertext_signal_link_selected_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -116,18 +109,12 @@ void Hypertext_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_link = &get_link_vfunc_callback;
   klass->get_n_links = &get_n_links_vfunc_callback;
   klass->get_link_index = &get_link_index_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->link_selected = &link_selected_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 AtkHyperlink* Hypertext_Class::get_link_vfunc_callback(AtkHypertext* self, gint link_index)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -140,20 +127,16 @@ AtkHyperlink* Hypertext_Class::get_link_vfunc_callback(AtkHypertext* self, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->get_link_vfunc(link_index
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -170,6 +153,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkHyperlink* RType;
   return RType();
 }
+
 gint Hypertext_Class::get_n_links_vfunc_callback(AtkHypertext* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -182,19 +166,15 @@ gint Hypertext_Class::get_n_links_vfunc_callback(AtkHypertext* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_links_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -211,6 +191,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Hypertext_Class::get_link_index_vfunc_callback(AtkHypertext* self, gint char_index)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -223,20 +204,16 @@ gint Hypertext_Class::get_link_index_vfunc_callback(AtkHypertext* self, gint cha
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_link_index_vfunc(char_index
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -253,9 +230,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Hypertext_Class::link_selected_callback(AtkHypertext* self, gint p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -268,20 +244,16 @@ void Hypertext_Class::link_selected_callback(AtkHypertext* self, gint p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_link_selected(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -295,7 +267,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->link_selected)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Hypertext_Class::wrap_new(GObject* object)
@@ -345,7 +316,7 @@ Glib::RefPtr<Hyperlink> Hypertext::get_link(int link_index)
 
 Glib::RefPtr<const Hyperlink> Hypertext::get_link(int link_index) const
 {
-  return const_cast<Hypertext*>(this)->get_link(link_index);
+  return Glib::wrap(atk_hypertext_get_link(const_cast<AtkHypertext*>(gobj()), link_index));
 }
 
 int Hypertext::get_n_links() const
@@ -365,7 +336,6 @@ Glib::SignalProxy1< void,int > Hypertext::signal_link_selected()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Atk::Hypertext::on_link_selected(int link_index)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -376,9 +346,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->link_selected)
     (*base->link_selected)(gobj(),link_index);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 Glib::RefPtr<Hyperlink> Atk::Hypertext::get_link_vfunc(int link_index) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -392,6 +361,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::RefPtr<Hyperlink> RType;
   return RType();
 }
+
 int Atk::Hypertext::get_n_links_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -405,6 +375,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Hypertext::get_link_index_vfunc(int char_index) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -418,7 +389,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/hypertext.h b/libs/gtkmm2/atk/atkmm/hypertext.h
index 406b138dfb..090827662a 100644
--- a/libs/gtkmm2/atk/atkmm/hypertext.h
+++ b/libs/gtkmm2/atk/atkmm/hypertext.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_HYPERTEXT_H
 #define _ATKMM_HYPERTEXT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -128,43 +127,24 @@ public:
   int get_link_index(int char_index) const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %link_selected(int link_index)</tt>
-   */
-
   Glib::SignalProxy1< void,int > signal_link_selected();
 
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Hyperlink> get_link_vfunc(int link_index);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_links_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_link_index_vfunc(int char_index) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual Glib::RefPtr<Hyperlink> get_link_vfunc(int link_index);
+    virtual int get_n_links_vfunc() const;
+    virtual int get_link_index_vfunc(int char_index) const;
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_link_selected(int link_index);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -183,6 +163,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_HYPERTEXT_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/image.cc b/libs/gtkmm2/atk/atkmm/image.cc
index b557a6b929..2f1df28c18 100644
--- a/libs/gtkmm2/atk/atkmm/image.cc
+++ b/libs/gtkmm2/atk/atkmm/image.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/image.h>
 #include <atkmm/private/image_p.h>
 
@@ -74,18 +73,12 @@ void Image_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->set_image_description = &set_image_description_vfunc_callback;
   klass->get_image_description = &get_image_description_vfunc_callback;
   klass->get_image_position = &get_image_position_vfunc_callback;
   klass->get_image_size = &get_image_size_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gboolean Image_Class::set_image_description_vfunc_callback(AtkImage* self, const gchar* description)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -98,20 +91,16 @@ gboolean Image_Class::set_image_description_vfunc_callback(AtkImage* self, const
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_image_description_vfunc(Glib::convert_const_gchar_ptr_to_ustring(description)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -128,6 +117,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 const gchar* Image_Class::get_image_description_vfunc_callback(AtkImage* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -140,19 +130,15 @@ const gchar* Image_Class::get_image_description_vfunc_callback(AtkImage* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_image_description_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -169,6 +155,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 void Image_Class::get_image_position_vfunc_callback(AtkImage* self, gint* x, gint* y, AtkCoordType coord_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -181,22 +168,18 @@ void Image_Class::get_image_position_vfunc_callback(AtkImage* self, gint* x, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_image_position_vfunc(*(x)
 , *(y)
 , ((CoordType)(coord_type))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -210,6 +193,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_image_position)(self, x, y, coord_type);
   }
 }
+
 void Image_Class::get_image_size_vfunc_callback(AtkImage* self, gint* width, gint* height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -222,21 +206,17 @@ void Image_Class::get_image_size_vfunc_callback(AtkImage* self, gint* width, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_image_size_vfunc(*(width)
 , *(height)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -250,10 +230,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_image_size)(self, width, height);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Image_Class::wrap_new(GObject* object)
@@ -308,19 +284,15 @@ Glib::ustring Image::get_image_description() const
 
 void Image::get_image_size(int& width, int& height) const
 {
-atk_image_get_image_size(const_cast<AtkImage*>(gobj()), &width, &height); 
+  atk_image_get_image_size(const_cast<AtkImage*>(gobj()), &width, &height);
 }
 
 void Image::get_image_position(int& x, int& y, CoordType coord_type) const
 {
-atk_image_get_image_position(const_cast<AtkImage*>(gobj()), &x, &y, ((AtkCoordType)(coord_type))); 
+  atk_image_get_image_position(const_cast<AtkImage*>(gobj()), &x, &y, ((AtkCoordType)(coord_type)));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 bool Atk::Image::set_image_description_vfunc(const Glib::ustring& description) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -334,6 +306,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 const char* Atk::Image::get_image_description_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -347,6 +320,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const char* RType;
   return RType();
 }
+
 void Atk::Image::get_image_position_vfunc(int& x, int& y, CoordType coord_type) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -357,6 +331,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_image_position)
     (*base->get_image_position)(const_cast<AtkImage*>(gobj()),&x,&y,((AtkCoordType)(coord_type)));
 }
+
 void Atk::Image::get_image_size_vfunc(int& width, int& height) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -367,7 +342,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_image_size)
     (*base->get_image_size)(const_cast<AtkImage*>(gobj()),&width,&height);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/image.h b/libs/gtkmm2/atk/atkmm/image.h
index 9c36aa57ef..a6af34884a 100644
--- a/libs/gtkmm2/atk/atkmm/image.h
+++ b/libs/gtkmm2/atk/atkmm/image.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_IMAGE_H
 #define _ATKMM_IMAGE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -136,39 +135,22 @@ public:
   void get_image_position(int& x, int& y, CoordType coord_type) const;
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_image_description_vfunc(const Glib::ustring& description);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const char* get_image_description_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual bool set_image_description_vfunc(const Glib::ustring& description);
+    virtual const char* get_image_description_vfunc() const;
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_image_position_vfunc(int& x, int& y, CoordType coord_type) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_image_size_vfunc(int& width, int& height) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void get_image_position_vfunc(int& x, int& y, CoordType coord_type) const;
+    virtual void get_image_size_vfunc(int& width, int& height) const;
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -187,6 +169,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_IMAGE_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/implementor.cc b/libs/gtkmm2/atk/atkmm/implementor.cc
index fc70956d86..303bf3d0a1 100644
--- a/libs/gtkmm2/atk/atkmm/implementor.cc
+++ b/libs/gtkmm2/atk/atkmm/implementor.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/implementor.h>
 #include <atkmm/private/implementor_p.h>
 
@@ -74,15 +73,9 @@ void Implementor_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->ref_accessible = &ref_accessible_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 AtkObject* Implementor_Class::ref_accessible_vfunc_callback(AtkImplementor* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -95,19 +88,15 @@ AtkObject* Implementor_Class::ref_accessible_vfunc_callback(AtkImplementor* self
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->ref_accessibile_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -124,10 +113,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Implementor_Class::wrap_new(GObject* object)
@@ -170,10 +155,6 @@ GType Implementor::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 Glib::RefPtr<Object> Atk::Implementor::ref_accessibile_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -182,12 +163,11 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
 )  );
 
   if(base && base->ref_accessible)
-    return Glib::wrap((*base->ref_accessible)(gobj()), true);
+    return Glib::wrap((*base->ref_accessible)(gobj()));
 
   typedef Glib::RefPtr<Object> RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/implementor.h b/libs/gtkmm2/atk/atkmm/implementor.h
index f25fe1a7db..7df786ce27 100644
--- a/libs/gtkmm2/atk/atkmm/implementor.h
+++ b/libs/gtkmm2/atk/atkmm/implementor.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_IMPLEMENTOR_H
 #define _ATKMM_IMPLEMENTOR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -94,26 +93,18 @@ private:
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Object> ref_accessibile_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual Glib::RefPtr<Object> ref_accessibile_vfunc();
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -132,6 +123,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_IMPLEMENTOR_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/noopobject.cc b/libs/gtkmm2/atk/atkmm/noopobject.cc
index ad39d3bed2..c9c78627cd 100644
--- a/libs/gtkmm2/atk/atkmm/noopobject.cc
+++ b/libs/gtkmm2/atk/atkmm/noopobject.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/noopobject.h>
 #include <atkmm/private/noopobject_p.h>
 
@@ -84,19 +83,8 @@ void NoOpObject_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* NoOpObject_Class::wrap_new(GObject* object)
 {
@@ -139,13 +127,6 @@ GType NoOpObject::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Atk
 
 
diff --git a/libs/gtkmm2/atk/atkmm/noopobject.h b/libs/gtkmm2/atk/atkmm/noopobject.h
index 1421c0f084..b5ee9bed0c 100644
--- a/libs/gtkmm2/atk/atkmm/noopobject.h
+++ b/libs/gtkmm2/atk/atkmm/noopobject.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_NOOPOBJECT_H
 #define _ATKMM_NOOPOBJECT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -117,17 +116,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/atk/atkmm/object.cc b/libs/gtkmm2/atk/atkmm/object.cc
index b129a0af67..44e7301691 100644
--- a/libs/gtkmm2/atk/atkmm/object.cc
+++ b/libs/gtkmm2/atk/atkmm/object.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/object.h>
 #include <atkmm/private/object_p.h>
 
@@ -70,8 +69,7 @@ Glib::ObjectBase* Object_Class::wrap_new(GObject* object)
 namespace
 {
 
-
-static void Object_signal_children_changed_callback(AtkObject* self, guint p0,gpointer p1,void* data)
+void Object_signal_children_changed_callback(AtkObject* self, guint p0,gpointer p1,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,guint,gpointer > SlotType;
@@ -79,23 +77,19 @@ static void Object_signal_children_changed_callback(AtkObject* self, guint p0,gp
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0, p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Object_signal_children_changed_info =
+const Glib::SignalProxyInfo Object_signal_children_changed_info =
 {
   "children_changed",
   (GCallback) &Object_signal_children_changed_callback,
@@ -103,7 +97,7 @@ static const Glib::SignalProxyInfo Object_signal_children_changed_info =
 };
 
 
-static void Object_signal_focus_event_callback(AtkObject* self, gboolean p0,void* data)
+void Object_signal_focus_event_callback(AtkObject* self, gboolean p0,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,bool > SlotType;
@@ -111,24 +105,20 @@ static void Object_signal_focus_event_callback(AtkObject* self, gboolean p0,void
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Object_signal_focus_event_info =
+const Glib::SignalProxyInfo Object_signal_focus_event_info =
 {
   "focus_event",
   (GCallback) &Object_signal_focus_event_callback,
@@ -136,7 +126,7 @@ static const Glib::SignalProxyInfo Object_signal_focus_event_info =
 };
 
 
-static void Object_signal_property_change_callback(AtkObject* self, AtkPropertyValues* p0,void* data)
+void Object_signal_property_change_callback(AtkObject* self, AtkPropertyValues* p0,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,AtkPropertyValues* > SlotType;
@@ -144,23 +134,19 @@ static void Object_signal_property_change_callback(AtkObject* self, AtkPropertyV
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Object_signal_property_change_info =
+const Glib::SignalProxyInfo Object_signal_property_change_info =
 {
   "property_change",
   (GCallback) &Object_signal_property_change_callback,
@@ -168,7 +154,7 @@ static const Glib::SignalProxyInfo Object_signal_property_change_info =
 };
 
 
-static void Object_signal_state_change_callback(AtkObject* self, const gchar* p0,gboolean p1,void* data)
+void Object_signal_state_change_callback(AtkObject* self, const gchar* p0,gboolean p1,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,const Glib::ustring&,bool > SlotType;
@@ -176,25 +162,21 @@ static void Object_signal_state_change_callback(AtkObject* self, const gchar* p0
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Object_signal_state_change_info =
+const Glib::SignalProxyInfo Object_signal_state_change_info =
 {
   "state_change",
   (GCallback) &Object_signal_state_change_callback,
@@ -202,7 +184,7 @@ static const Glib::SignalProxyInfo Object_signal_state_change_info =
 };
 
 
-static const Glib::SignalProxyInfo Object_signal_visible_data_changed_info =
+const Glib::SignalProxyInfo Object_signal_visible_data_changed_info =
 {
   "visible_data_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -210,7 +192,7 @@ static const Glib::SignalProxyInfo Object_signal_visible_data_changed_info =
 };
 
 
-static void Object_signal_active_descendant_changed_callback(AtkObject* self, gpointer* p0,void* data)
+void Object_signal_active_descendant_changed_callback(AtkObject* self, gpointer* p0,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,void** > SlotType;
@@ -218,31 +200,26 @@ static void Object_signal_active_descendant_changed_callback(AtkObject* self, gp
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Object_signal_active_descendant_changed_info =
+const Glib::SignalProxyInfo Object_signal_active_descendant_changed_info =
 {
   "active_descendant_changed",
   (GCallback) &Object_signal_active_descendant_changed_callback,
   (GCallback) &Object_signal_active_descendant_changed_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -295,23 +272,15 @@ void Object_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->children_changed = &children_changed_callback;
   klass->focus_event = &focus_event_callback;
   klass->property_change = &property_change_callback;
   klass->state_change = &state_change_callback;
   klass->visible_data_changed = &visible_data_changed_callback;
   klass->active_descendant_changed = &active_descendant_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Object_Class::children_changed_callback(AtkObject* self, guint p0, gpointer p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -324,19 +293,15 @@ void Object_Class::children_changed_callback(AtkObject* self, guint p0, gpointer
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_children_changed(p0, p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -349,6 +314,7 @@ void Object_Class::children_changed_callback(AtkObject* self, guint p0, gpointer
       (*base->children_changed)(self, p0, p1);
   }
 }
+
 void Object_Class::focus_event_callback(AtkObject* self, gboolean p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -361,20 +327,16 @@ void Object_Class::focus_event_callback(AtkObject* self, gboolean p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_focus_event(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -387,6 +349,7 @@ void Object_Class::focus_event_callback(AtkObject* self, gboolean p0)
       (*base->focus_event)(self, p0);
   }
 }
+
 void Object_Class::property_change_callback(AtkObject* self, AtkPropertyValues* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -399,19 +362,15 @@ void Object_Class::property_change_callback(AtkObject* self, AtkPropertyValues*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_property_change(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -424,6 +383,7 @@ void Object_Class::property_change_callback(AtkObject* self, AtkPropertyValues*
       (*base->property_change)(self, p0);
   }
 }
+
 void Object_Class::state_change_callback(AtkObject* self, const gchar* p0, gboolean p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -436,21 +396,17 @@ void Object_Class::state_change_callback(AtkObject* self, const gchar* p0, gbool
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_state_change(Glib::convert_const_gchar_ptr_to_ustring(p0)
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -463,6 +419,7 @@ void Object_Class::state_change_callback(AtkObject* self, const gchar* p0, gbool
       (*base->state_change)(self, p0, p1);
   }
 }
+
 void Object_Class::visible_data_changed_callback(AtkObject* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -475,19 +432,15 @@ void Object_Class::visible_data_changed_callback(AtkObject* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_visible_data_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -500,6 +453,7 @@ void Object_Class::visible_data_changed_callback(AtkObject* self)
       (*base->visible_data_changed)(self);
   }
 }
+
 void Object_Class::active_descendant_changed_callback(AtkObject* self, gpointer* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -512,20 +466,16 @@ void Object_Class::active_descendant_changed_callback(AtkObject* self, gpointer*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_active_descendant_changed(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -538,7 +488,6 @@ void Object_Class::active_descendant_changed_callback(AtkObject* self, gpointer*
       (*base->active_descendant_changed)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 /* The implementation: */
@@ -590,10 +539,10 @@ Glib::RefPtr<Atk::Object> Object::get_parent()
 {
 
   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_object_get_parent(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 int Object::get_n_accessible_children() const
@@ -610,10 +559,10 @@ Glib::RefPtr<RelationSet> Object::get_relation_set()
 {
 
   Glib::RefPtr<RelationSet> retvalue = Glib::wrap(atk_object_ref_relation_set(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Role Object::get_role() const
@@ -633,27 +582,27 @@ int Object::get_index_in_parent()
 
 void Object::set_name(const Glib::ustring& name)
 {
-atk_object_set_name(gobj(), name.c_str()); 
+  atk_object_set_name(gobj(), name.c_str());
 }
 
 void Object::set_description(const Glib::ustring& description)
 {
-atk_object_set_description(gobj(), description.c_str()); 
+  atk_object_set_description(gobj(), description.c_str());
 }
 
 void Object::set_parent(const Glib::RefPtr<Atk::Object>& parent)
 {
-atk_object_set_parent(gobj(), Glib::unwrap(parent)); 
+  atk_object_set_parent(gobj(), Glib::unwrap(parent));
 }
 
 void Object::set_role(Role role)
 {
-atk_object_set_role(gobj(), ((AtkRole)(role))); 
+  atk_object_set_role(gobj(), ((AtkRole)(role)));
 }
 
 void Object::notify_state_change(State state, bool value)
 {
-atk_object_notify_state_change(gobj(), state, static_cast<int>(value)); 
+  atk_object_notify_state_change(gobj(), state, static_cast<int>(value));
 }
 
 bool Object::add_relationship(RelationType relationship, const Glib::RefPtr<Object>& target)
@@ -672,207 +621,153 @@ Glib::SignalProxy2< void,guint,gpointer > Object::signal_children_changed()
   return Glib::SignalProxy2< void,guint,gpointer >(this, &Object_signal_children_changed_info);
 }
 
-
 Glib::SignalProxy1< void,bool > Object::signal_focus_event()
 {
   return Glib::SignalProxy1< void,bool >(this, &Object_signal_focus_event_info);
 }
 
-
 Glib::SignalProxy1< void,AtkPropertyValues* > Object::signal_property_change()
 {
   return Glib::SignalProxy1< void,AtkPropertyValues* >(this, &Object_signal_property_change_info);
 }
 
-
 Glib::SignalProxy2< void,const Glib::ustring&,bool > Object::signal_state_change()
 {
   return Glib::SignalProxy2< void,const Glib::ustring&,bool >(this, &Object_signal_state_change_info);
 }
 
-
 Glib::SignalProxy0< void > Object::signal_visible_data_changed()
 {
   return Glib::SignalProxy0< void >(this, &Object_signal_visible_data_changed_info);
 }
 
-
 Glib::SignalProxy1< void,void** > Object::signal_active_descendant_changed()
 {
   return Glib::SignalProxy1< void,void** >(this, &Object_signal_active_descendant_changed_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_description() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-description");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_description() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-description");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_parent() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_parent() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Object::property_accessible_value() 
 {
   return Glib::PropertyProxy<double>(this, "accessible-value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Object::property_accessible_value() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "accessible-value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Object::property_accessible_role() 
 {
   return Glib::PropertyProxy<int>(this, "accessible-role");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_role() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-role");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_component_layer() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-component-layer");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Object::property_accessible_component_mdi_zorder() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "accessible-component-mdi-zorder");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_caption() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-caption");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_caption() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-caption");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_column_description() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-column-description");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_column_description() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-column-description");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_column_header() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-column-header");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_column_header() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-column-header");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Object::property_accessible_table_row_description() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "accessible-table-row-description");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Object::property_accessible_table_row_description() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "accessible-table-row-description");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_row_header() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-row-header");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_row_header() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-row-header");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_summary() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Atk::Object> >(this, "accessible-table-summary");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > Object::property_accessible_table_summary() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> >(this, "accessible-table-summary");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Atk::Object::on_children_changed(guint change_index, gpointer changed_child)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -882,6 +777,7 @@ void Atk::Object::on_children_changed(guint change_index, gpointer changed_child
   if(base && base->children_changed)
     (*base->children_changed)(gobj(),change_index,changed_child);
 }
+
 void Atk::Object::on_focus_event(bool focus_in)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -891,6 +787,7 @@ void Atk::Object::on_focus_event(bool focus_in)
   if(base && base->focus_event)
     (*base->focus_event)(gobj(),static_cast<int>(focus_in));
 }
+
 void Atk::Object::on_property_change(AtkPropertyValues* values)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -900,6 +797,7 @@ void Atk::Object::on_property_change(AtkPropertyValues* values)
   if(base && base->property_change)
     (*base->property_change)(gobj(),values);
 }
+
 void Atk::Object::on_state_change(const Glib::ustring& name, bool state_set)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -909,6 +807,7 @@ void Atk::Object::on_state_change(const Glib::ustring& name, bool state_set)
   if(base && base->state_change)
     (*base->state_change)(gobj(),name.c_str(),static_cast<int>(state_set));
 }
+
 void Atk::Object::on_visible_data_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -918,6 +817,7 @@ void Atk::Object::on_visible_data_changed()
   if(base && base->visible_data_changed)
     (*base->visible_data_changed)(gobj());
 }
+
 void Atk::Object::on_active_descendant_changed(void** child)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -927,10 +827,6 @@ void Atk::Object::on_active_descendant_changed(void** child)
   if(base && base->active_descendant_changed)
     (*base->active_descendant_changed)(gobj(),child);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/object.h b/libs/gtkmm2/atk/atkmm/object.h
index 5b2431b57a..047cb2a254 100644
--- a/libs/gtkmm2/atk/atkmm/object.h
+++ b/libs/gtkmm2/atk/atkmm/object.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_OBJECT_H
 #define _ATKMM_OBJECT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -321,65 +320,32 @@ public:
   bool remove_relationship(RelationType relationship, const Glib::RefPtr<Object>& target);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %children_changed(guint change_index, gpointer changed_child)</tt>
-   */
-
   Glib::SignalProxy2< void,guint,gpointer > signal_children_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %focus_event(bool focus_in)</tt>
-   */
-
   Glib::SignalProxy1< void,bool > signal_focus_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %property_change(AtkPropertyValues* values)</tt>
-   */
-
   Glib::SignalProxy1< void,AtkPropertyValues* > signal_property_change();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %state_change(const Glib::ustring& name, bool state_set)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::ustring&,bool > signal_state_change();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %visible_data_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_visible_data_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %active_descendant_changed(void** child)</tt>
-   */
-
   Glib::SignalProxy1< void,void** > signal_active_descendant_changed();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Object instance's name formatted for assistive technology access.
+  /** Object instance's name formatted for assistive technology access.
    *
    * 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_accessible_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Object instance's name formatted for assistive technology access.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -387,19 +353,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Description of an object
+  /** Description of an object
    *
    * 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_accessible_description() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Description of an object
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -407,19 +369,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_description() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the parent has changed.
+  /** Is used to notify that the parent has 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::RefPtr<Atk::Object> > property_accessible_parent() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the parent has changed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -427,19 +385,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_parent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the value has changed.
+  /** Is used to notify that the value has 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<double> property_accessible_value() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the value has changed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -447,19 +401,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_accessible_value() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The accessible role of this object.
+  /** The accessible role of this object.
    *
    * 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_accessible_role() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The accessible role of this object.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -467,41 +417,33 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_accessible_role() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The accessible layer of this object.
+  /** The accessible layer of this object.
    *
    * 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_accessible_component_layer() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The accessible MDI value of this object.
+  /** The accessible MDI value of this object.
    *
    * 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_accessible_component_mdi_zorder() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the table caption has changed; this property should not be used. accessible-table-caption-object should be used instead.
+  /** Is used to notify that the table caption has changed; this property should not be used. accessible-table-caption-object should be used instead.
    *
    * 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_accessible_table_caption() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the table caption has changed; this property should not be used. accessible-table-caption-object should be used instead.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -509,19 +451,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_table_caption() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the table column description has changed.
+  /** Is used to notify that the table column description has 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_accessible_table_column_description() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the table column description has changed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -529,19 +467,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_table_column_description() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the table column header has changed.
+  /** Is used to notify that the table column header has 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::RefPtr<Atk::Object> > property_accessible_table_column_header() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the table column header has changed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -549,19 +483,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_table_column_header() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the table row description has changed.
+  /** Is used to notify that the table row description has 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_accessible_table_row_description() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the table row description has changed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -569,19 +499,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_accessible_table_row_description() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the table row header has changed.
+  /** Is used to notify that the table row header has 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::RefPtr<Atk::Object> > property_accessible_table_row_header() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the table row header has changed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -589,19 +515,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_table_row_header() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is used to notify that the table summary has changed.
+  /** Is used to notify that the table summary has 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::RefPtr<Atk::Object> > property_accessible_table_summary() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is used to notify that the table summary has changed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -609,30 +531,23 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Atk::Object> > property_accessible_table_summary() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_children_changed(guint change_index, gpointer changed_child);
   virtual void on_focus_event(bool focus_in);
   virtual void on_property_change(AtkPropertyValues* values);
   virtual void on_state_change(const Glib::ustring& name, bool state_set);
   virtual void on_visible_data_changed();
   virtual void on_active_descendant_changed(void** child);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/atk/atkmm/objectaccessible.cc b/libs/gtkmm2/atk/atkmm/objectaccessible.cc
index 265180b830..da4136bef7 100644
--- a/libs/gtkmm2/atk/atkmm/objectaccessible.cc
+++ b/libs/gtkmm2/atk/atkmm/objectaccessible.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/objectaccessible.h>
 #include <atkmm/private/objectaccessible_p.h>
 
@@ -27,6 +26,7 @@
  */
 
 #include <atk/atkgobjectaccessible.h>
+
 namespace
 {
 } // anonymous namespace
@@ -75,19 +75,8 @@ void ObjectAccessible_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ObjectAccessible_Class::wrap_new(GObject* object)
 {
@@ -134,15 +123,20 @@ Glib::RefPtr<Glib::Object> ObjectAccessible::get_object()
 {
 
   Glib::RefPtr<Glib::Object> retvalue = Glib::wrap(atk_gobject_accessible_get_object(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Glib::Object> ObjectAccessible::get_object() const
 {
-  return const_cast<ObjectAccessible*>(this)->get_object();
+
+  Glib::RefPtr<const Glib::Object> retvalue = Glib::wrap(atk_gobject_accessible_get_object(const_cast<AtkGObjectAccessible*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<Glib::Object>& obj)
@@ -155,7 +149,6 @@ Glib::RefPtr<Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<Glib::
   return retvalue;
 }
 
-
 Glib::RefPtr<const Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<const Glib::Object>& obj)
 {
 
@@ -167,13 +160,6 @@ Glib::RefPtr<const Atk::Object> ObjectAccessible::for_object(const Glib::RefPtr<
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Atk
 
 
diff --git a/libs/gtkmm2/atk/atkmm/objectaccessible.h b/libs/gtkmm2/atk/atkmm/objectaccessible.h
index f3ed6f5b9c..d266f9a97e 100644
--- a/libs/gtkmm2/atk/atkmm/objectaccessible.h
+++ b/libs/gtkmm2/atk/atkmm/objectaccessible.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_OBJECTACCESSIBLE_H
 #define _ATKMM_OBJECTACCESSIBLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -119,17 +118,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/atk/atkmm/private/action_p.h b/libs/gtkmm2/atk/atkmm/private/action_p.h
index 9372291a66..bb3c5afa09 100644
--- a/libs/gtkmm2/atk/atkmm/private/action_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/action_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_ACTION_P_H
 #define _ATKMM_ACTION_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,26 +27,21 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gboolean do_action_vfunc_callback(AtkAction* self, gint i);
   static gint get_n_actions_vfunc_callback(AtkAction* self);
   static const gchar* get_description_vfunc_callback(AtkAction* self, gint i);
   static const gchar* get_name_vfunc_callback(AtkAction* self, gint i);
   static const gchar* get_keybinding_vfunc_callback(AtkAction* self, gint i);
   static gboolean set_description_vfunc_callback(AtkAction* self, gint i, const gchar* desc);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_ACTION_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/component_p.h b/libs/gtkmm2/atk/atkmm/private/component_p.h
index 7526cdcb68..010df9e92f 100644
--- a/libs/gtkmm2/atk/atkmm/private/component_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/component_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_COMPONENT_P_H
 #define _ATKMM_COMPONENT_P_H
-
-
 #include <atk/atkcomponent.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,14 +27,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static guint add_focus_handler_vfunc_callback(AtkComponent* self, AtkFocusHandler handler);
   static gboolean contains_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type);
   static AtkObject* ref_accessible_at_point_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type);
@@ -50,12 +45,10 @@ protected:
   static gboolean set_extents_vfunc_callback(AtkComponent* self, gint x, gint y, gint width, gint height, AtkCoordType coord_type);
   static gboolean set_position_vfunc_callback(AtkComponent* self, gint x, gint y, AtkCoordType coord_type);
   static gboolean set_size_vfunc_callback(AtkComponent* self, gint width, gint height);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_COMPONENT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/document_p.h b/libs/gtkmm2/atk/atkmm/private/document_p.h
index 387a5822e7..01115486b5 100644
--- a/libs/gtkmm2/atk/atkmm/private/document_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/document_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_DOCUMENT_P_H
 #define _ATKMM_DOCUMENT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,22 +27,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static const gchar* get_document_type_vfunc_callback(AtkDocument* self);
   static gpointer get_document_vfunc_callback(AtkDocument* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_DOCUMENT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/editabletext_p.h b/libs/gtkmm2/atk/atkmm/private/editabletext_p.h
index e812f68489..fb5004ed1d 100644
--- a/libs/gtkmm2/atk/atkmm/private/editabletext_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/editabletext_p.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_EDITABLETEXT_P_H
 #define _ATKMM_EDITABLETEXT_P_H
 
-
 #include <glibmm/private/interface_p.h>
 
 namespace Atk
@@ -27,14 +26,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gboolean set_run_attributes_vfunc_callback(AtkEditableText* self, AtkAttributeSet* attrib_set, gint start_offset, gint end_offset);
   static void set_text_contents_vfunc_callback(AtkEditableText* self, const gchar* string);
   static void insert_text_vfunc_callback(AtkEditableText* self, const gchar* string, gint length, gint* position);
@@ -42,12 +38,10 @@ protected:
   static void cut_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos);
   static void delete_text_vfunc_callback(AtkEditableText* self, gint start_pos, gint end_pos);
   static void paste_text_vfunc_callback(AtkEditableText* self, gint position);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_EDITABLETEXT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/hyperlink_p.h b/libs/gtkmm2/atk/atkmm/private/hyperlink_p.h
index b4b57fc745..a5d9e61275 100644
--- a/libs/gtkmm2/atk/atkmm/private/hyperlink_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/hyperlink_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_HYPERLINK_P_H
 #define _ATKMM_HYPERLINK_P_H
-
-
 #include <glibmm/private/object_p.h>
 #include <atk/atkobject.h>
 
@@ -33,15 +31,12 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 link_activated_callback(AtkHyperlink* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gchar* get_uri_vfunc_callback(AtkHyperlink* self, gint i);
   static AtkObject* get_object_vfunc_callback(AtkHyperlink* self, gint i);
   static gint get_end_index_vfunc_callback(AtkHyperlink* self);
@@ -50,12 +45,10 @@ protected:
   static gint get_n_anchors_vfunc_callback(AtkHyperlink* self);
   static guint link_state_vfunc_callback(AtkHyperlink* self);
   static gboolean is_selected_link_vfunc_callback(AtkHyperlink* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_HYPERLINK_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/hypertext_p.h b/libs/gtkmm2/atk/atkmm/private/hypertext_p.h
index cf6ec7a240..79eaad32c5 100644
--- a/libs/gtkmm2/atk/atkmm/private/hypertext_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/hypertext_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_HYPERTEXT_P_H
 #define _ATKMM_HYPERTEXT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,24 +27,19 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 link_selected_callback(AtkHypertext* self, gint p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static AtkHyperlink* get_link_vfunc_callback(AtkHypertext* self, gint link_index);
   static gint get_n_links_vfunc_callback(AtkHypertext* self);
   static gint get_link_index_vfunc_callback(AtkHypertext* self, gint char_index);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_HYPERTEXT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/image_p.h b/libs/gtkmm2/atk/atkmm/private/image_p.h
index f7275ba0c9..b2e8d327ca 100644
--- a/libs/gtkmm2/atk/atkmm/private/image_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/image_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_IMAGE_P_H
 #define _ATKMM_IMAGE_P_H
-
-
 #include <atk/atkimage.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,24 +27,19 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gboolean set_image_description_vfunc_callback(AtkImage* self, const gchar* description);
   static const gchar* get_image_description_vfunc_callback(AtkImage* self);
   static void get_image_position_vfunc_callback(AtkImage* self, gint* x, gint* y, AtkCoordType coord_type);
   static void get_image_size_vfunc_callback(AtkImage* self, gint* width, gint* height);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_IMAGE_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/implementor_p.h b/libs/gtkmm2/atk/atkmm/private/implementor_p.h
index 70359d4122..7c5fc8804f 100644
--- a/libs/gtkmm2/atk/atkmm/private/implementor_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/implementor_p.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_IMPLEMENTOR_P_H
 #define _ATKMM_IMPLEMENTOR_P_H
 
-
 #include <glibmm/private/interface_p.h>
 
 namespace Atk
@@ -27,21 +26,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static AtkObject* ref_accessible_vfunc_callback(AtkImplementor* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_IMPLEMENTOR_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/noopobject_p.h b/libs/gtkmm2/atk/atkmm/private/noopobject_p.h
index 54b1f81709..afa515b316 100644
--- a/libs/gtkmm2/atk/atkmm/private/noopobject_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/noopobject_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_NOOPOBJECT_P_H
 #define _ATKMM_NOOPOBJECT_P_H
-
-
 #include <atkmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_NOOPOBJECT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/object_p.h b/libs/gtkmm2/atk/atkmm/private/object_p.h
index 8af90b1c95..f65e8f8c08 100644
--- a/libs/gtkmm2/atk/atkmm/private/object_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/object_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_OBJECT_P_H
 #define _ATKMM_OBJECT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -42,16 +39,12 @@ protected:
   static void state_change_callback(AtkObject* self, const gchar* p0, gboolean p1);
   static void visible_data_changed_callback(AtkObject* self);
   static void active_descendant_changed_callback(AtkObject* self, gpointer* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_OBJECT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/objectaccessible_p.h b/libs/gtkmm2/atk/atkmm/private/objectaccessible_p.h
index 37be5dd403..b94c1320e5 100644
--- a/libs/gtkmm2/atk/atkmm/private/objectaccessible_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/objectaccessible_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_OBJECTACCESSIBLE_P_H
 #define _ATKMM_OBJECTACCESSIBLE_P_H
-
-
 #include <atkmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_OBJECTACCESSIBLE_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/relation_p.h b/libs/gtkmm2/atk/atkmm/private/relation_p.h
index 075b012730..63513db828 100644
--- a/libs/gtkmm2/atk/atkmm/private/relation_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/relation_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_RELATION_P_H
 #define _ATKMM_RELATION_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_RELATION_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/relationset_p.h b/libs/gtkmm2/atk/atkmm/private/relationset_p.h
index 719ba5607e..8d3787e6e6 100644
--- a/libs/gtkmm2/atk/atkmm/private/relationset_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/relationset_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_RELATIONSET_P_H
 #define _ATKMM_RELATIONSET_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_RELATIONSET_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/selection_p.h b/libs/gtkmm2/atk/atkmm/private/selection_p.h
index 11956c38fc..dd5f27702a 100644
--- a/libs/gtkmm2/atk/atkmm/private/selection_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/selection_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_SELECTION_P_H
 #define _ATKMM_SELECTION_P_H
-
-
 #include <atk/atkobject.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,15 +27,12 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 selection_changed_callback(AtkSelection* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gboolean add_selection_vfunc_callback(AtkSelection* self, gint i);
   static gboolean clear_selection_vfunc_callback(AtkSelection* self);
   static AtkObject* ref_selection_vfunc_callback(AtkSelection* self, gint i);
@@ -45,12 +40,10 @@ protected:
   static gboolean is_child_selected_vfunc_callback(AtkSelection* self, gint i);
   static gboolean remove_selection_vfunc_callback(AtkSelection* self, gint i);
   static gboolean select_all_selection_vfunc_callback(AtkSelection* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_SELECTION_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/stateset_p.h b/libs/gtkmm2/atk/atkmm/private/stateset_p.h
index 8d6691c0d2..51dd352ec0 100644
--- a/libs/gtkmm2/atk/atkmm/private/stateset_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/stateset_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_STATESET_P_H
 #define _ATKMM_STATESET_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_STATESET_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/streamablecontent_p.h b/libs/gtkmm2/atk/atkmm/private/streamablecontent_p.h
index acc2aa6dbe..7c22e8c8ec 100644
--- a/libs/gtkmm2/atk/atkmm/private/streamablecontent_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/streamablecontent_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_STREAMABLECONTENT_P_H
 #define _ATKMM_STREAMABLECONTENT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,23 +27,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static int get_n_mime_types_vfunc_callback(AtkStreamableContent* self);
   static const gchar* get_mime_type_vfunc_callback(AtkStreamableContent* self, gint i);
   static GIOChannel* get_stream_vfunc_callback(AtkStreamableContent* self, const gchar* mime_type);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_STREAMABLECONTENT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/table_p.h b/libs/gtkmm2/atk/atkmm/private/table_p.h
index 6d8d3d1cac..5516bb05c9 100644
--- a/libs/gtkmm2/atk/atkmm/private/table_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/table_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _ATKMM_TABLE_P_H
 #define _ATKMM_TABLE_P_H
-
-
 #include <atk/atkobject.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,7 +27,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -40,10 +37,8 @@ protected:
   static void row_reordered_callback(AtkTable* self);
   static void column_reordered_callback(AtkTable* self);
   static void model_changed_callback(AtkTable* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static AtkObject* ref_at_vfunc_callback(AtkTable* self, gint row, gint column);
   static gint get_index_at_vfunc_callback(AtkTable* self, gint row, gint column);
   static gint get_column_at_index_vfunc_callback(AtkTable* self, gint index_);
@@ -73,12 +68,10 @@ protected:
   static gboolean remove_column_selection_vfunc_callback(AtkTable* self, gint column);
   static gint get_selected_columns_vfunc_callback(AtkTable* self, gint** selected);
   static gint get_selected_rows_vfunc_callback(AtkTable* self, gint** selected);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_TABLE_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/text_p.h b/libs/gtkmm2/atk/atkmm/private/text_p.h
index 8888776aca..3ccc748965 100644
--- a/libs/gtkmm2/atk/atkmm/private/text_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/text_p.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_TEXT_P_H
 #define _ATKMM_TEXT_P_H
 
-
 #include <glibmm/private/interface_p.h>
 
 namespace Atk
@@ -27,7 +26,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -35,10 +33,8 @@ protected:
   static void text_caret_moved_callback(AtkText* self, gint p0);
   static void text_selection_changed_callback(AtkText* self);
   static void text_attributes_changed_callback(AtkText* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gchar* get_text_vfunc_callback(AtkText* self, gint start_offset, gint end_offset);
   static gunichar get_character_at_offset_vfunc_callback(AtkText* self, gint offset);
   static gchar* get_text_after_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset);
@@ -56,12 +52,10 @@ protected:
   static gboolean remove_selection_vfunc_callback(AtkText* self, gint selection_num);
   static gboolean set_selection_vfunc_callback(AtkText* self, gint selection_num, gint start_offset, gint end_offset);
   static gboolean set_caret_offset_vfunc_callback(AtkText* self, gint offset);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_TEXT_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/private/value_p.h b/libs/gtkmm2/atk/atkmm/private/value_p.h
index 00fcb81ae8..f712e3cd70 100644
--- a/libs/gtkmm2/atk/atkmm/private/value_p.h
+++ b/libs/gtkmm2/atk/atkmm/private/value_p.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_VALUE_P_H
 #define _ATKMM_VALUE_P_H
 
-
 #include <glibmm/private/interface_p.h>
 
 namespace Atk
@@ -27,24 +26,19 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void get_current_value_vfunc_callback(AtkValue* self, GValue* value);
   static void get_maximum_value_vfunc_callback(AtkValue* self, GValue* value);
   static void get_minimum_value_vfunc_callback(AtkValue* self, GValue* value);
   static gboolean set_current_value_vfunc_callback(AtkValue* self, const GValue* value);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Atk
 
-
 #endif /* _ATKMM_VALUE_P_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/relation.cc b/libs/gtkmm2/atk/atkmm/relation.cc
index e56df0ee10..94c3fe2d48 100644
--- a/libs/gtkmm2/atk/atkmm/relation.cc
+++ b/libs/gtkmm2/atk/atkmm/relation.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/relation.h>
 #include <atkmm/private/relation_p.h>
 
@@ -114,19 +113,8 @@ void Relation_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Relation_Class::wrap_new(GObject* object)
 {
@@ -180,17 +168,10 @@ RelationType Relation::get_relation_type() const
 
 void Relation::add_target(const Glib::RefPtr<Atk::Object>& target)
 {
-atk_relation_add_target(gobj(), Glib::unwrap(target)); 
+  atk_relation_add_target(gobj(), Glib::unwrap(target));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Atk
 
 
diff --git a/libs/gtkmm2/atk/atkmm/relation.h b/libs/gtkmm2/atk/atkmm/relation.h
index f0b1fe2f44..683b938947 100644
--- a/libs/gtkmm2/atk/atkmm/relation.h
+++ b/libs/gtkmm2/atk/atkmm/relation.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_RELATION_H
 #define _ATKMM_RELATION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -154,12 +153,6 @@ public:
   Glib::ArrayHandle< Glib::RefPtr<const Atk::Object> > get_target() const;
   
   
-  /** Adds the specified AtkObject to the target for the relation, if it is
-   * not already present.
-   * 
-   * Since: 1.9
-   * @param target An Atk::Object.
-   */
   void add_target(const Glib::RefPtr<Atk::Object>& target);
 
 
@@ -167,17 +160,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/atk/atkmm/relationset.cc b/libs/gtkmm2/atk/atkmm/relationset.cc
index 3638f4ece1..2060639bc1 100644
--- a/libs/gtkmm2/atk/atkmm/relationset.cc
+++ b/libs/gtkmm2/atk/atkmm/relationset.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/relationset.h>
 #include <atkmm/private/relationset_p.h>
 
@@ -76,19 +75,8 @@ void RelationSet_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* RelationSet_Class::wrap_new(GObject* object)
 {
@@ -149,12 +137,12 @@ bool RelationSet::set_contains(RelationType relationship)
 
 void RelationSet::set_remove(const Glib::RefPtr<Relation>& relation)
 {
-atk_relation_set_remove(gobj(), Glib::unwrap(relation)); 
+  atk_relation_set_remove(gobj(), Glib::unwrap(relation));
 }
 
 void RelationSet::set_add(const Glib::RefPtr<Relation>& relation)
 {
-atk_relation_set_add(gobj(), Glib::unwrap(relation)); 
+  atk_relation_set_add(gobj(), Glib::unwrap(relation));
 }
 
 int RelationSet::get_n_relations() const
@@ -166,35 +154,28 @@ Glib::RefPtr<Relation> RelationSet::get_relation(gint i)
 {
 
   Glib::RefPtr<Relation> retvalue = Glib::wrap(atk_relation_set_get_relation(gobj(), i));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Relation> RelationSet::get_relation(RelationType relationship)
 {
 
   Glib::RefPtr<Relation> retvalue = Glib::wrap(atk_relation_set_get_relation_by_type(gobj(), ((AtkRelationType)(relationship))));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 void RelationSet::add_relation_by_type(RelationType relationship, const Glib::RefPtr<Atk::Object>& target)
 {
-atk_relation_set_add_relation_by_type(gobj(), ((AtkRelationType)(relationship)), Glib::unwrap(target)); 
+  atk_relation_set_add_relation_by_type(gobj(), ((AtkRelationType)(relationship)), Glib::unwrap(target));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Atk
 
 
diff --git a/libs/gtkmm2/atk/atkmm/relationset.h b/libs/gtkmm2/atk/atkmm/relationset.h
index a2a52c2fac..3702083fa5 100644
--- a/libs/gtkmm2/atk/atkmm/relationset.h
+++ b/libs/gtkmm2/atk/atkmm/relationset.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_RELATIONSET_H
 #define _ATKMM_RELATIONSET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -138,15 +137,6 @@ public:
   Glib::RefPtr<Relation> get_relation(RelationType relationship);
   
   
-  /** Add a new relation of the specified type with the specified target to 
-   * the current relation set if the relation set does not contain a relation
-   * of that type. If it is does contain a relation of that typea the target
-   * is added to the relation.
-   * 
-   * Since: 1.9
-   * @param relationship An Atk::RelationType.
-   * @param target An Atk::Object.
-   */
   void add_relation_by_type(RelationType relationship, const Glib::RefPtr<Atk::Object>& target);
 
 
@@ -154,17 +144,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/atk/atkmm/selection.cc b/libs/gtkmm2/atk/atkmm/selection.cc
index ed5fb629e7..95c6a0a60a 100644
--- a/libs/gtkmm2/atk/atkmm/selection.cc
+++ b/libs/gtkmm2/atk/atkmm/selection.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/selection.h>
 #include <atkmm/private/selection_p.h>
 
@@ -31,15 +30,13 @@
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Selection_signal_selection_changed_info =
+const Glib::SignalProxyInfo Selection_signal_selection_changed_info =
 {
   "selection_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -84,7 +81,6 @@ void Selection_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->add_selection = &add_selection_vfunc_callback;
   klass->clear_selection = &clear_selection_vfunc_callback;
   klass->ref_selection = &ref_selection_vfunc_callback;
@@ -92,14 +88,9 @@ void Selection_Class::iface_init_function(void* g_iface, void*)
   klass->is_child_selected = &is_child_selected_vfunc_callback;
   klass->remove_selection = &remove_selection_vfunc_callback;
   klass->select_all_selection = &select_all_selection_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->selection_changed = &selection_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gboolean Selection_Class::add_selection_vfunc_callback(AtkSelection* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -112,20 +103,16 @@ gboolean Selection_Class::add_selection_vfunc_callback(AtkSelection* self, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->add_selection_vfunc(i
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -142,6 +129,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Selection_Class::clear_selection_vfunc_callback(AtkSelection* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -154,19 +142,15 @@ gboolean Selection_Class::clear_selection_vfunc_callback(AtkSelection* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->clear_selection_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -183,6 +167,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 AtkObject* Selection_Class::ref_selection_vfunc_callback(AtkSelection* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -195,20 +180,16 @@ AtkObject* Selection_Class::ref_selection_vfunc_callback(AtkSelection* self, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap_copy(obj->get_selection_vfunc(i
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -225,6 +206,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
+
 gint Selection_Class::get_selection_count_vfunc_callback(AtkSelection* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -237,19 +219,15 @@ gint Selection_Class::get_selection_count_vfunc_callback(AtkSelection* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_selection_count_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -266,6 +244,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gboolean Selection_Class::is_child_selected_vfunc_callback(AtkSelection* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -278,20 +257,16 @@ gboolean Selection_Class::is_child_selected_vfunc_callback(AtkSelection* self, g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->is_child_selected_vfunc(i
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -308,6 +283,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Selection_Class::remove_selection_vfunc_callback(AtkSelection* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -320,20 +296,16 @@ gboolean Selection_Class::remove_selection_vfunc_callback(AtkSelection* self, gi
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->remove_selection_vfunc(i
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -350,6 +322,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Selection_Class::select_all_selection_vfunc_callback(AtkSelection* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -362,19 +335,15 @@ gboolean Selection_Class::select_all_selection_vfunc_callback(AtkSelection* self
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->select_all_selection_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -391,9 +360,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Selection_Class::selection_changed_callback(AtkSelection* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -406,19 +374,15 @@ void Selection_Class::selection_changed_callback(AtkSelection* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_selection_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -432,7 +396,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->selection_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Selection_Class::wrap_new(GObject* object)
@@ -517,7 +480,6 @@ Glib::SignalProxy0< void > Selection::signal_selection_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Atk::Selection::on_selection_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -528,9 +490,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->selection_changed)
     (*base->selection_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 bool Atk::Selection::add_selection_vfunc(int i) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -544,6 +505,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Selection::clear_selection_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -557,6 +519,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 Glib::RefPtr<Atk::Object> Atk::Selection::get_selection_vfunc(int i) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -570,6 +533,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 int Atk::Selection::get_selection_count_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -583,6 +547,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 bool Atk::Selection::is_child_selected_vfunc(int i) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -596,6 +561,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Selection::remove_selection_vfunc(int i) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -609,6 +575,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Selection::select_all_selection_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -622,7 +589,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/selection.h b/libs/gtkmm2/atk/atkmm/selection.h
index eaf17896a9..62185ed0d9 100644
--- a/libs/gtkmm2/atk/atkmm/selection.h
+++ b/libs/gtkmm2/atk/atkmm/selection.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_SELECTION_H
 #define _ATKMM_SELECTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -164,60 +163,29 @@ public:
   bool select_all_selection();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %selection_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_selection_changed();
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool add_selection_vfunc(int i);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool clear_selection_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_selection_vfunc(int i);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_selection_count_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool is_child_selected_vfunc(int i) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool remove_selection_vfunc(int i);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool select_all_selection_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual bool add_selection_vfunc(int i);
+    virtual bool clear_selection_vfunc();
+    virtual Glib::RefPtr<Atk::Object> get_selection_vfunc(int i);
+    virtual int get_selection_count_vfunc() const;
+    virtual bool is_child_selected_vfunc(int i) const;
+    virtual bool remove_selection_vfunc(int i);
+    virtual bool select_all_selection_vfunc();
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_selection_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -236,6 +204,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_SELECTION_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/stateset.cc b/libs/gtkmm2/atk/atkmm/stateset.cc
index bb8d7745fa..6feb4d6ee3 100644
--- a/libs/gtkmm2/atk/atkmm/stateset.cc
+++ b/libs/gtkmm2/atk/atkmm/stateset.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/stateset.h>
 #include <atkmm/private/stateset_p.h>
 
@@ -100,19 +99,8 @@ void StateSet_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* StateSet_Class::wrap_new(GObject* object)
 {
@@ -178,7 +166,7 @@ bool StateSet::add_state(Atk::StateType type)
 
 void StateSet::clear_states()
 {
-atk_state_set_clear_states(gobj()); 
+  atk_state_set_clear_states(gobj());
 }
 
 bool StateSet::contains_state(Atk::StateType type)
@@ -207,13 +195,6 @@ Glib::RefPtr<StateSet> StateSet::xor_sets(const Glib::RefPtr<StateSet>& compare_
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Atk
 
 
diff --git a/libs/gtkmm2/atk/atkmm/stateset.h b/libs/gtkmm2/atk/atkmm/stateset.h
index 559e702cc4..f3e8f70504 100644
--- a/libs/gtkmm2/atk/atkmm/stateset.h
+++ b/libs/gtkmm2/atk/atkmm/stateset.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_STATESET_H
 #define _ATKMM_STATESET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -77,7 +76,6 @@ enum StateType
   STATE_MANAGES_DESCENDANTS,
   STATE_INDETERMINATE,
   STATE_TRUNCATED,
-  STATE_REQUIRED,
   STATE_LAST_DEFINED
 };
 
@@ -222,17 +220,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/atk/atkmm/streamablecontent.cc b/libs/gtkmm2/atk/atkmm/streamablecontent.cc
index 8c10a6b13d..13916f861d 100644
--- a/libs/gtkmm2/atk/atkmm/streamablecontent.cc
+++ b/libs/gtkmm2/atk/atkmm/streamablecontent.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/streamablecontent.h>
 #include <atkmm/private/streamablecontent_p.h>
 
@@ -81,17 +80,11 @@ void StreamableContent_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_n_mime_types = &get_n_mime_types_vfunc_callback;
   klass->get_mime_type = &get_mime_type_vfunc_callback;
   klass->get_stream = &get_stream_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 int StreamableContent_Class::get_n_mime_types_vfunc_callback(AtkStreamableContent* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -104,19 +97,15 @@ int StreamableContent_Class::get_n_mime_types_vfunc_callback(AtkStreamableConten
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_mime_types_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -133,6 +122,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef int RType;
   return RType();
 }
+
 const gchar* StreamableContent_Class::get_mime_type_vfunc_callback(AtkStreamableContent* self, gint i)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -145,20 +135,16 @@ const gchar* StreamableContent_Class::get_mime_type_vfunc_callback(AtkStreamable
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_mime_type_vfunc(i
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -175,6 +161,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 GIOChannel* StreamableContent_Class::get_stream_vfunc_callback(AtkStreamableContent* self, const gchar* mime_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -187,20 +174,16 @@ GIOChannel* StreamableContent_Class::get_stream_vfunc_callback(AtkStreamableCont
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_stream_vfunc(Glib::convert_const_gchar_ptr_to_ustring(mime_type)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -217,10 +200,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef GIOChannel* RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* StreamableContent_Class::wrap_new(GObject* object)
@@ -279,10 +258,6 @@ Glib::RefPtr<Glib::IOChannel> StreamableContent::get_stream(const Glib::ustring&
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 int Atk::StreamableContent::get_n_mime_types_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -296,6 +271,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 const gchar* Atk::StreamableContent::get_mime_type_vfunc(int i) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -309,6 +285,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const gchar* RType;
   return RType();
 }
+
 GIOChannel* Atk::StreamableContent::get_stream_vfunc(const Glib::ustring& mime_type) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -322,7 +299,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef GIOChannel* RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/streamablecontent.h b/libs/gtkmm2/atk/atkmm/streamablecontent.h
index fe93cf72cb..698aaef86b 100644
--- a/libs/gtkmm2/atk/atkmm/streamablecontent.h
+++ b/libs/gtkmm2/atk/atkmm/streamablecontent.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_STREAMABLECONTENT_H
 #define _ATKMM_STREAMABLECONTENT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -118,34 +117,20 @@ public:
   Glib::RefPtr<Glib::IOChannel> get_stream(const Glib::ustring& mime_type);
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_mime_types_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const gchar* get_mime_type_vfunc(int i) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual int get_n_mime_types_vfunc() const;
+    virtual const gchar* get_mime_type_vfunc(int i) const;
+    virtual GIOChannel* get_stream_vfunc(const Glib::ustring& mime_type);                                                   
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual GIOChannel* get_stream_vfunc(const Glib::ustring& mime_type);
-#endif //GLIBMM_VFUNCS_ENABLED
-                                                   
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -164,6 +149,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_STREAMABLECONTENT_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/table.cc b/libs/gtkmm2/atk/atkmm/table.cc
index c03cca5ac3..335fb55ece 100644
--- a/libs/gtkmm2/atk/atkmm/table.cc
+++ b/libs/gtkmm2/atk/atkmm/table.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/table.h>
 #include <atkmm/private/table_p.h>
 
@@ -53,8 +52,7 @@ Glib::ArrayHandle<int> Table::get_selected_rows() const
 namespace
 {
 
-
-static void Table_signal_row_inserted_callback(AtkTable* self, gint p0,gint p1,void* data)
+void Table_signal_row_inserted_callback(AtkTable* self, gint p0,gint p1,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,int,int > SlotType;
@@ -62,25 +60,21 @@ static void Table_signal_row_inserted_callback(AtkTable* self, gint p0,gint p1,v
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Table_signal_row_inserted_info =
+const Glib::SignalProxyInfo Table_signal_row_inserted_info =
 {
   "row_inserted",
   (GCallback) &Table_signal_row_inserted_callback,
@@ -88,7 +82,7 @@ static const Glib::SignalProxyInfo Table_signal_row_inserted_info =
 };
 
 
-static void Table_signal_column_inserted_callback(AtkTable* self, gint p0,gint p1,void* data)
+void Table_signal_column_inserted_callback(AtkTable* self, gint p0,gint p1,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,int,int > SlotType;
@@ -96,25 +90,21 @@ static void Table_signal_column_inserted_callback(AtkTable* self, gint p0,gint p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Table_signal_column_inserted_info =
+const Glib::SignalProxyInfo Table_signal_column_inserted_info =
 {
   "column_inserted",
   (GCallback) &Table_signal_column_inserted_callback,
@@ -122,7 +112,7 @@ static const Glib::SignalProxyInfo Table_signal_column_inserted_info =
 };
 
 
-static void Table_signal_row_deleted_callback(AtkTable* self, gint p0,gint p1,void* data)
+void Table_signal_row_deleted_callback(AtkTable* self, gint p0,gint p1,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,int,int > SlotType;
@@ -130,25 +120,21 @@ static void Table_signal_row_deleted_callback(AtkTable* self, gint p0,gint p1,vo
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Table_signal_row_deleted_info =
+const Glib::SignalProxyInfo Table_signal_row_deleted_info =
 {
   "row_deleted",
   (GCallback) &Table_signal_row_deleted_callback,
@@ -156,7 +142,7 @@ static const Glib::SignalProxyInfo Table_signal_row_deleted_info =
 };
 
 
-static void Table_signal_column_deleted_callback(AtkTable* self, gint p0,gint p1,void* data)
+void Table_signal_column_deleted_callback(AtkTable* self, gint p0,gint p1,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,int,int > SlotType;
@@ -164,25 +150,21 @@ static void Table_signal_column_deleted_callback(AtkTable* self, gint p0,gint p1
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Table_signal_column_deleted_info =
+const Glib::SignalProxyInfo Table_signal_column_deleted_info =
 {
   "column_deleted",
   (GCallback) &Table_signal_column_deleted_callback,
@@ -190,7 +172,7 @@ static const Glib::SignalProxyInfo Table_signal_column_deleted_info =
 };
 
 
-static const Glib::SignalProxyInfo Table_signal_row_reordered_info =
+const Glib::SignalProxyInfo Table_signal_row_reordered_info =
 {
   "row_reordered",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -198,7 +180,7 @@ static const Glib::SignalProxyInfo Table_signal_row_reordered_info =
 };
 
 
-static const Glib::SignalProxyInfo Table_signal_column_reordered_info =
+const Glib::SignalProxyInfo Table_signal_column_reordered_info =
 {
   "column_reordered",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -206,14 +188,13 @@ static const Glib::SignalProxyInfo Table_signal_column_reordered_info =
 };
 
 
-static const Glib::SignalProxyInfo Table_signal_model_changed_info =
+const Glib::SignalProxyInfo Table_signal_model_changed_info =
 {
   "model_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -258,7 +239,6 @@ void Table_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->ref_at = &ref_at_vfunc_callback;
   klass->get_index_at = &get_index_at_vfunc_callback;
   klass->get_column_at_index = &get_column_at_index_vfunc_callback;
@@ -288,9 +268,6 @@ void Table_Class::iface_init_function(void* g_iface, void*)
   klass->remove_column_selection = &remove_column_selection_vfunc_callback;
   klass->get_selected_columns = &get_selected_columns_vfunc_callback;
   klass->get_selected_rows = &get_selected_rows_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->row_inserted = &row_inserted_callback;
   klass->column_inserted = &column_inserted_callback;
   klass->row_deleted = &row_deleted_callback;
@@ -298,10 +275,8 @@ void Table_Class::iface_init_function(void* g_iface, void*)
   klass->row_reordered = &row_reordered_callback;
   klass->column_reordered = &column_reordered_callback;
   klass->model_changed = &model_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 AtkObject* Table_Class::ref_at_vfunc_callback(AtkTable* self, gint row, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -314,21 +289,17 @@ AtkObject* Table_Class::ref_at_vfunc_callback(AtkTable* self, gint row, gint col
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap_copy(obj->get_at_vfunc(row
 , column
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -345,6 +316,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
+
 gint Table_Class::get_index_at_vfunc_callback(AtkTable* self, gint row, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -357,21 +329,17 @@ gint Table_Class::get_index_at_vfunc_callback(AtkTable* self, gint row, gint col
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_index_at_vfunc(row
 , column
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -388,6 +356,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Table_Class::get_column_at_index_vfunc_callback(AtkTable* self, gint index_)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -400,20 +369,16 @@ gint Table_Class::get_column_at_index_vfunc_callback(AtkTable* self, gint index_
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_column_at_index_vfunc(index_
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -430,6 +395,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Table_Class::get_row_at_index_vfunc_callback(AtkTable* self, gint index_)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -442,20 +408,16 @@ gint Table_Class::get_row_at_index_vfunc_callback(AtkTable* self, gint index_)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_row_at_index_vfunc(index_
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -472,6 +434,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Table_Class::get_n_columns_vfunc_callback(AtkTable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -484,19 +447,15 @@ gint Table_Class::get_n_columns_vfunc_callback(AtkTable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_columns_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -513,6 +472,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Table_Class::get_n_rows_vfunc_callback(AtkTable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -525,19 +485,15 @@ gint Table_Class::get_n_rows_vfunc_callback(AtkTable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_rows_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -554,6 +510,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Table_Class::get_column_extent_at_vfunc_callback(AtkTable* self, gint row, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -566,21 +523,17 @@ gint Table_Class::get_column_extent_at_vfunc_callback(AtkTable* self, gint row,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_column_extent_at_vfunc(row
 , column
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -597,6 +550,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Table_Class::get_row_extent_at_vfunc_callback(AtkTable* self, gint row, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -609,21 +563,17 @@ gint Table_Class::get_row_extent_at_vfunc_callback(AtkTable* self, gint row, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_row_extent_at_vfunc(row
 , column
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -640,6 +590,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 AtkObject* Table_Class::get_caption_vfunc_callback(AtkTable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -652,19 +603,15 @@ AtkObject* Table_Class::get_caption_vfunc_callback(AtkTable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->get_caption_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -681,6 +628,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
+
 const gchar* Table_Class::get_column_description_vfunc_callback(AtkTable* self, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -693,20 +641,16 @@ const gchar* Table_Class::get_column_description_vfunc_callback(AtkTable* self,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_column_description_vfunc(column
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -723,6 +667,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 AtkObject* Table_Class::get_column_header_vfunc_callback(AtkTable* self, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -735,20 +680,16 @@ AtkObject* Table_Class::get_column_header_vfunc_callback(AtkTable* self, gint co
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->get_column_header_vfunc(column
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -765,6 +706,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
+
 const gchar* Table_Class::get_row_description_vfunc_callback(AtkTable* self, gint row)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -777,20 +719,16 @@ const gchar* Table_Class::get_row_description_vfunc_callback(AtkTable* self, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_row_description_vfunc(row
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -807,6 +745,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef const gchar* RType;
   return RType();
 }
+
 AtkObject* Table_Class::get_row_header_vfunc_callback(AtkTable* self, gint row)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -819,20 +758,16 @@ AtkObject* Table_Class::get_row_header_vfunc_callback(AtkTable* self, gint row)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->get_row_header_vfunc(row
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -849,6 +784,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
+
 AtkObject* Table_Class::get_summary_vfunc_callback(AtkTable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -861,19 +797,15 @@ AtkObject* Table_Class::get_summary_vfunc_callback(AtkTable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->get_summary_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -890,6 +822,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkObject* RType;
   return RType();
 }
+
 void Table_Class::set_caption_vfunc_callback(AtkTable* self, AtkObject* caption)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -902,20 +835,16 @@ void Table_Class::set_caption_vfunc_callback(AtkTable* self, AtkObject* caption)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_caption_vfunc(Glib::wrap(caption, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -929,6 +858,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_caption)(self, caption);
   }
 }
+
 void Table_Class::set_column_description_vfunc_callback(AtkTable* self, gint column, const gchar* description)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -941,21 +871,17 @@ void Table_Class::set_column_description_vfunc_callback(AtkTable* self, gint col
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_column_description_vfunc(column
 , description
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -969,6 +895,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_column_description)(self, column, description);
   }
 }
+
 void Table_Class::set_column_header_vfunc_callback(AtkTable* self, gint column, AtkObject* header)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -981,21 +908,17 @@ void Table_Class::set_column_header_vfunc_callback(AtkTable* self, gint column,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_column_header_vfunc(column
 , Glib::wrap(header, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1009,6 +932,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_column_header)(self, column, header);
   }
 }
+
 void Table_Class::set_row_description_vfunc_callback(AtkTable* self, gint row, const gchar* description)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1021,21 +945,17 @@ void Table_Class::set_row_description_vfunc_callback(AtkTable* self, gint row, c
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_row_description_vfunc(row
 , description
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1049,6 +969,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_row_description)(self, row, description);
   }
 }
+
 void Table_Class::set_row_header_vfunc_callback(AtkTable* self, gint row, AtkObject* header)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1061,21 +982,17 @@ void Table_Class::set_row_header_vfunc_callback(AtkTable* self, gint row, AtkObj
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_row_header_vfunc(row
 , Glib::wrap(header, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1089,6 +1006,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_row_header)(self, row, header);
   }
 }
+
 void Table_Class::set_summary_vfunc_callback(AtkTable* self, AtkObject* accessible)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1101,20 +1019,16 @@ void Table_Class::set_summary_vfunc_callback(AtkTable* self, AtkObject* accessib
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_summary_vfunc(Glib::wrap(accessible, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1128,6 +1042,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_summary)(self, accessible);
   }
 }
+
 gboolean Table_Class::is_column_selected_vfunc_callback(AtkTable* self, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1140,20 +1055,16 @@ gboolean Table_Class::is_column_selected_vfunc_callback(AtkTable* self, gint col
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->is_column_selected_vfunc(column
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1170,6 +1081,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Table_Class::is_row_selected_vfunc_callback(AtkTable* self, gint row)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1182,20 +1094,16 @@ gboolean Table_Class::is_row_selected_vfunc_callback(AtkTable* self, gint row)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->is_row_selected_vfunc(row
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1212,6 +1120,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Table_Class::is_selected_vfunc_callback(AtkTable* self, gint row, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1224,21 +1133,17 @@ gboolean Table_Class::is_selected_vfunc_callback(AtkTable* self, gint row, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->is_selected_vfunc(row
 , column
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1255,6 +1160,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Table_Class::add_row_selection_vfunc_callback(AtkTable* self, gint row)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1267,20 +1173,16 @@ gboolean Table_Class::add_row_selection_vfunc_callback(AtkTable* self, gint row)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->add_row_selection_vfunc(row
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1297,6 +1199,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Table_Class::remove_row_selection_vfunc_callback(AtkTable* self, gint row)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1309,20 +1212,16 @@ gboolean Table_Class::remove_row_selection_vfunc_callback(AtkTable* self, gint r
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->remove_row_selection_vfunc(row
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1339,6 +1238,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Table_Class::add_column_selection_vfunc_callback(AtkTable* self, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1351,20 +1251,16 @@ gboolean Table_Class::add_column_selection_vfunc_callback(AtkTable* self, gint c
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->add_column_selection_vfunc(column
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1381,6 +1277,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Table_Class::remove_column_selection_vfunc_callback(AtkTable* self, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1393,20 +1290,16 @@ gboolean Table_Class::remove_column_selection_vfunc_callback(AtkTable* self, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->remove_column_selection_vfunc(column
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1423,6 +1316,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gint Table_Class::get_selected_columns_vfunc_callback(AtkTable* self, gint** selected)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1435,20 +1329,16 @@ gint Table_Class::get_selected_columns_vfunc_callback(AtkTable* self, gint** sel
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_selected_columns_vfunc(selected
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1465,6 +1355,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Table_Class::get_selected_rows_vfunc_callback(AtkTable* self, gint** selected)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1477,20 +1368,16 @@ gint Table_Class::get_selected_rows_vfunc_callback(AtkTable* self, gint** select
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_selected_rows_vfunc(selected
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1507,9 +1394,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Table_Class::row_inserted_callback(AtkTable* self, gint p0, gint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1522,21 +1408,17 @@ void Table_Class::row_inserted_callback(AtkTable* self, gint p0, gint p1)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_inserted(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1550,6 +1432,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->row_inserted)(self, p0, p1);
   }
 }
+
 void Table_Class::column_inserted_callback(AtkTable* self, gint p0, gint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1562,21 +1445,17 @@ void Table_Class::column_inserted_callback(AtkTable* self, gint p0, gint p1)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_column_inserted(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1590,6 +1469,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->column_inserted)(self, p0, p1);
   }
 }
+
 void Table_Class::row_deleted_callback(AtkTable* self, gint p0, gint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1602,21 +1482,17 @@ void Table_Class::row_deleted_callback(AtkTable* self, gint p0, gint p1)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_deleted(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1630,6 +1506,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->row_deleted)(self, p0, p1);
   }
 }
+
 void Table_Class::column_deleted_callback(AtkTable* self, gint p0, gint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1642,21 +1519,17 @@ void Table_Class::column_deleted_callback(AtkTable* self, gint p0, gint p1)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_column_deleted(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1670,6 +1543,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->column_deleted)(self, p0, p1);
   }
 }
+
 void Table_Class::row_reordered_callback(AtkTable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1682,19 +1556,15 @@ void Table_Class::row_reordered_callback(AtkTable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_reordered();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1708,6 +1578,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->row_reordered)(self);
   }
 }
+
 void Table_Class::column_reordered_callback(AtkTable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1720,19 +1591,15 @@ void Table_Class::column_reordered_callback(AtkTable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_column_reordered();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1746,6 +1613,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->column_reordered)(self);
   }
 }
+
 void Table_Class::model_changed_callback(AtkTable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1758,19 +1626,15 @@ void Table_Class::model_changed_callback(AtkTable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_model_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1784,7 +1648,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->model_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Table_Class::wrap_new(GObject* object)
@@ -1871,15 +1734,20 @@ Glib::RefPtr<Atk::Object> Table::get_caption()
 {
 
   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_caption(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Atk::Object> Table::get_caption() const
 {
-  return const_cast<Table*>(this)->get_caption();
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_caption(const_cast<AtkTable*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::ustring Table::get_column_description(int column) const
@@ -1891,15 +1759,20 @@ Glib::RefPtr<Atk::Object> Table::get_column_header(int column)
 {
 
   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_column_header(gobj(), column));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Atk::Object> Table::get_column_header(int column) const
 {
-  return const_cast<Table*>(this)->get_column_header(column);
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_column_header(const_cast<AtkTable*>(gobj()), column));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::ustring Table::get_row_description(int row) const
@@ -1911,60 +1784,70 @@ Glib::RefPtr<Atk::Object> Table::get_row_header(int row)
 {
 
   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_row_header(gobj(), row));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Atk::Object> Table::get_row_header(int row) const
 {
-  return const_cast<Table*>(this)->get_row_header(row);
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_row_header(const_cast<AtkTable*>(gobj()), row));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Atk::Object> Table::get_summary()
 {
 
   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(atk_table_get_summary(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Atk::Object> Table::get_summary() const
 {
-  return const_cast<Table*>(this)->get_summary();
+
+  Glib::RefPtr<const Atk::Object> retvalue = Glib::wrap(atk_table_get_summary(const_cast<AtkTable*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Table::set_caption(const Glib::RefPtr<Atk::Object>& caption)
 {
-atk_table_set_caption(gobj(), Glib::unwrap(caption)); 
+  atk_table_set_caption(gobj(), Glib::unwrap(caption));
 }
 
 void Table::set_column_description(int column, const Glib::ustring& description)
 {
-atk_table_set_column_description(gobj(), column, description.c_str()); 
+  atk_table_set_column_description(gobj(), column, description.c_str());
 }
 
 void Table::set_column_header(int column, const Glib::RefPtr<Atk::Object>& header)
 {
-atk_table_set_column_header(gobj(), column, Glib::unwrap(header)); 
+  atk_table_set_column_header(gobj(), column, Glib::unwrap(header));
 }
 
 void Table::set_row_description(int row, const Glib::ustring& description)
 {
-atk_table_set_row_description(gobj(), row, description.c_str()); 
+  atk_table_set_row_description(gobj(), row, description.c_str());
 }
 
 void Table::set_row_header(int row, const Glib::RefPtr<Atk::Object>& header)
 {
-atk_table_set_row_header(gobj(), row, Glib::unwrap(header)); 
+  atk_table_set_row_header(gobj(), row, Glib::unwrap(header));
 }
 
 void Table::set_summary(const Glib::RefPtr<Atk::Object>& accessible)
 {
-atk_table_set_summary(gobj(), Glib::unwrap(accessible)); 
+  atk_table_set_summary(gobj(), Glib::unwrap(accessible));
 }
 
 bool Table::is_column_selected(int column) const
@@ -2008,44 +1891,37 @@ Glib::SignalProxy2< void,int,int > Table::signal_row_inserted()
   return Glib::SignalProxy2< void,int,int >(this, &Table_signal_row_inserted_info);
 }
 
-
 Glib::SignalProxy2< void,int,int > Table::signal_column_inserted()
 {
   return Glib::SignalProxy2< void,int,int >(this, &Table_signal_column_inserted_info);
 }
 
-
 Glib::SignalProxy2< void,int,int > Table::signal_row_deleted()
 {
   return Glib::SignalProxy2< void,int,int >(this, &Table_signal_row_deleted_info);
 }
 
-
 Glib::SignalProxy2< void,int,int > Table::signal_column_deleted()
 {
   return Glib::SignalProxy2< void,int,int >(this, &Table_signal_column_deleted_info);
 }
 
-
 Glib::SignalProxy0< void > Table::signal_row_reordered()
 {
   return Glib::SignalProxy0< void >(this, &Table_signal_row_reordered_info);
 }
 
-
 Glib::SignalProxy0< void > Table::signal_column_reordered()
 {
   return Glib::SignalProxy0< void >(this, &Table_signal_column_reordered_info);
 }
 
-
 Glib::SignalProxy0< void > Table::signal_model_changed()
 {
   return Glib::SignalProxy0< void >(this, &Table_signal_model_changed_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Atk::Table::on_row_inserted(int row, int num_inserted)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2056,6 +1932,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->row_inserted)
     (*base->row_inserted)(gobj(),row,num_inserted);
 }
+
 void Atk::Table::on_column_inserted(int column, int num_inserted)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2066,6 +1943,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->column_inserted)
     (*base->column_inserted)(gobj(),column,num_inserted);
 }
+
 void Atk::Table::on_row_deleted(int row, int num_deleted)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2076,6 +1954,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->row_deleted)
     (*base->row_deleted)(gobj(),row,num_deleted);
 }
+
 void Atk::Table::on_column_deleted(int column, int num_deleted)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2086,6 +1965,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->column_deleted)
     (*base->column_deleted)(gobj(),column,num_deleted);
 }
+
 void Atk::Table::on_row_reordered()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2096,6 +1976,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->row_reordered)
     (*base->row_reordered)(gobj());
 }
+
 void Atk::Table::on_column_reordered()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2106,6 +1987,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->column_reordered)
     (*base->column_reordered)(gobj());
 }
+
 void Atk::Table::on_model_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2116,9 +1998,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->model_changed)
     (*base->model_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 Glib::RefPtr<Atk::Object> Atk::Table::get_at_vfunc(int row, int column) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2132,6 +2013,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 int Atk::Table::get_index_at_vfunc(int row, int column) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2145,6 +2027,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Table::get_column_at_index_vfunc(int index) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2158,6 +2041,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Table::get_row_at_index_vfunc(int index) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2171,6 +2055,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Table::get_n_columns_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2184,6 +2069,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Table::get_n_rows_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2197,6 +2083,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Table::get_column_extent_at_vfunc(int row, int column) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2210,6 +2097,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Table::get_row_extent_at_vfunc(int row, int column) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2223,6 +2111,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 Glib::RefPtr<Atk::Object> Atk::Table::get_caption_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2231,11 +2120,12 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
 )  );
 
   if(base && base->get_caption)
-    return Glib::wrap((*base->get_caption)(gobj()), true);
+    return Glib::wrap((*base->get_caption)(gobj()));
 
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 const char* Atk::Table::get_column_description_vfunc(int column) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2249,6 +2139,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const char* RType;
   return RType();
 }
+
 Glib::RefPtr<Atk::Object> Atk::Table::get_column_header_vfunc(int column) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2257,11 +2148,12 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
 )  );
 
   if(base && base->get_column_header)
-    return Glib::wrap((*base->get_column_header)(gobj(),column), true);
+    return Glib::wrap((*base->get_column_header)(gobj(),column));
 
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 const char* Atk::Table::get_row_description_vfunc(int row) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2275,6 +2167,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef const char* RType;
   return RType();
 }
+
 Glib::RefPtr<Atk::Object> Atk::Table::get_row_header_vfunc(int row) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2283,11 +2176,12 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
 )  );
 
   if(base && base->get_row_header)
-    return Glib::wrap((*base->get_row_header)(gobj(),row), true);
+    return Glib::wrap((*base->get_row_header)(gobj(),row));
 
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 Glib::RefPtr<Atk::Object> Atk::Table::get_summary_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2296,11 +2190,12 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
 )  );
 
   if(base && base->get_summary)
-    return Glib::wrap((*base->get_summary)(gobj()), true);
+    return Glib::wrap((*base->get_summary)(gobj()));
 
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
+
 void Atk::Table::set_caption_vfunc(const Glib::RefPtr<Atk::Object>& caption) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2311,6 +2206,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_caption)
     (*base->set_caption)(gobj(),Glib::unwrap(caption));
 }
+
 void Atk::Table::set_column_description_vfunc(int column, const char* description) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2321,6 +2217,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_column_description)
     (*base->set_column_description)(gobj(),column,description);
 }
+
 void Atk::Table::set_column_header_vfunc(int column, const Glib::RefPtr<Atk::Object>& header) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2331,6 +2228,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_column_header)
     (*base->set_column_header)(gobj(),column,Glib::unwrap(header));
 }
+
 void Atk::Table::set_row_description_vfunc(int row, const char* description) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2341,6 +2239,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_row_description)
     (*base->set_row_description)(gobj(),row,description);
 }
+
 void Atk::Table::set_row_header_vfunc(int row, const Glib::RefPtr<Atk::Object>& header) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2351,6 +2250,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_row_header)
     (*base->set_row_header)(gobj(),row,Glib::unwrap(header));
 }
+
 void Atk::Table::set_summary_vfunc(const Glib::RefPtr<Atk::Object>& accessible) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2361,6 +2261,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_summary)
     (*base->set_summary)(gobj(),Glib::unwrap(accessible));
 }
+
 bool Atk::Table::is_column_selected_vfunc(int column) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2374,6 +2275,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Table::is_row_selected_vfunc(int row) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2387,6 +2289,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Table::is_selected_vfunc(int row, int column) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2400,6 +2303,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Table::add_row_selection_vfunc(int row) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2413,6 +2317,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Table::remove_row_selection_vfunc(int row) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2426,6 +2331,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Table::add_column_selection_vfunc(int column) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2439,6 +2345,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Table::remove_column_selection_vfunc(int column) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2452,6 +2359,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 int Atk::Table::get_selected_columns_vfunc(int** selected) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2465,6 +2373,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Table::get_selected_rows_vfunc(int** selected) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2478,7 +2387,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/table.h b/libs/gtkmm2/atk/atkmm/table.h
index c5b351f06a..f1936afd49 100644
--- a/libs/gtkmm2/atk/atkmm/table.h
+++ b/libs/gtkmm2/atk/atkmm/table.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_TABLE_H
 #define _ATKMM_TABLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -337,194 +336,68 @@ public:
   bool remove_column_selection(int column);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_inserted(int row, int num_inserted)</tt>
-   */
-
   Glib::SignalProxy2< void,int,int > signal_row_inserted();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %column_inserted(int column, int num_inserted)</tt>
-   */
-
   Glib::SignalProxy2< void,int,int > signal_column_inserted();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_deleted(int row, int num_deleted)</tt>
-   */
-
   Glib::SignalProxy2< void,int,int > signal_row_deleted();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %column_deleted(int column, int num_deleted)</tt>
-   */
-
   Glib::SignalProxy2< void,int,int > signal_column_deleted();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_reordered()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_row_reordered();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %column_reordered()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_column_reordered();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %model_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_model_changed();
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_at_vfunc(int row, int column);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_index_at_vfunc(int row, int column) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_column_at_index_vfunc(int index) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_row_at_index_vfunc(int index) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_columns_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_rows_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_column_extent_at_vfunc(int row, int column) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_row_extent_at_vfunc(int row, int column) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_caption_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const char* get_column_description_vfunc(int column) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_column_header_vfunc(int column);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual const char* get_row_description_vfunc(int row) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_row_header_vfunc(int row);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_summary_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_caption_vfunc(const Glib::RefPtr<Atk::Object>& caption);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_column_description_vfunc(int column, const char* description);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_column_header_vfunc(int column, const Glib::RefPtr<Atk::Object>& header);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_row_description_vfunc(int row, const char* description);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_row_header_vfunc(int row, const Glib::RefPtr<Atk::Object>& header);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_summary_vfunc(const Glib::RefPtr<Atk::Object>& accessible);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool is_column_selected_vfunc(int column) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool is_row_selected_vfunc(int row) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool is_selected_vfunc(int row, int column) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool add_row_selection_vfunc(int row);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool remove_row_selection_vfunc(int row);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool add_column_selection_vfunc(int column);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool remove_column_selection_vfunc(int column);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_selected_columns_vfunc(int** selected) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_selected_rows_vfunc(int** selected) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual Glib::RefPtr<Atk::Object> get_at_vfunc(int row, int column);
+    virtual int get_index_at_vfunc(int row, int column) const;
+    virtual int get_column_at_index_vfunc(int index) const;
+    virtual int get_row_at_index_vfunc(int index) const;
+    virtual int get_n_columns_vfunc() const;
+    virtual int get_n_rows_vfunc() const;
+    virtual int get_column_extent_at_vfunc(int row, int column) const;
+    virtual int get_row_extent_at_vfunc(int row, int column) const;
+    virtual Glib::RefPtr<Atk::Object> get_caption_vfunc();
+    virtual const char* get_column_description_vfunc(int column) const;
+    virtual Glib::RefPtr<Atk::Object> get_column_header_vfunc(int column);
+    virtual const char* get_row_description_vfunc(int row) const;
+    virtual Glib::RefPtr<Atk::Object> get_row_header_vfunc(int row);
+    virtual Glib::RefPtr<Atk::Object> get_summary_vfunc();
+    virtual void set_caption_vfunc(const Glib::RefPtr<Atk::Object>& caption);
+    virtual void set_column_description_vfunc(int column, const char* description);
+    virtual void set_column_header_vfunc(int column, const Glib::RefPtr<Atk::Object>& header);
+    virtual void set_row_description_vfunc(int row, const char* description);
+    virtual void set_row_header_vfunc(int row, const Glib::RefPtr<Atk::Object>& header);
+    virtual void set_summary_vfunc(const Glib::RefPtr<Atk::Object>& accessible);
+    virtual bool is_column_selected_vfunc(int column) const;
+    virtual bool is_row_selected_vfunc(int row) const;
+    virtual bool is_selected_vfunc(int row, int column) const;
+    virtual bool add_row_selection_vfunc(int row);
+    virtual bool remove_row_selection_vfunc(int row);
+    virtual bool add_column_selection_vfunc(int column);
+    virtual bool remove_column_selection_vfunc(int column);
+    virtual int get_selected_columns_vfunc(int** selected) const;
+    virtual int get_selected_rows_vfunc(int** selected) const;
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_row_inserted(int row, int num_inserted);
   virtual void on_column_inserted(int column, int num_inserted);
   virtual void on_row_deleted(int row, int num_deleted);
@@ -532,7 +405,6 @@ protected:
   virtual void on_row_reordered();
   virtual void on_column_reordered();
   virtual void on_model_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -551,6 +423,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_TABLE_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/text.cc b/libs/gtkmm2/atk/atkmm/text.cc
index 1212ce18ff..af101a5117 100644
--- a/libs/gtkmm2/atk/atkmm/text.cc
+++ b/libs/gtkmm2/atk/atkmm/text.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/text.h>
 #include <atkmm/private/text_p.h>
 
@@ -120,8 +119,7 @@ Glib::ustring TextAttribute::get_value(TextAttribute attribute, int index)
 namespace
 {
 
-
-static void Text_signal_text_changed_callback(AtkText* self, gint p0,gint p1,void* data)
+void Text_signal_text_changed_callback(AtkText* self, gint p0,gint p1,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,int,int > SlotType;
@@ -129,25 +127,21 @@ static void Text_signal_text_changed_callback(AtkText* self, gint p0,gint p1,voi
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Text_signal_text_changed_info =
+const Glib::SignalProxyInfo Text_signal_text_changed_info =
 {
   "text_changed",
   (GCallback) &Text_signal_text_changed_callback,
@@ -155,7 +149,7 @@ static const Glib::SignalProxyInfo Text_signal_text_changed_info =
 };
 
 
-static void Text_signal_text_caret_moved_callback(AtkText* self, gint p0,void* data)
+void Text_signal_text_caret_moved_callback(AtkText* self, gint p0,void* data)
 {
   using namespace Atk;
   typedef sigc::slot< void,int > SlotType;
@@ -163,24 +157,20 @@ static void Text_signal_text_caret_moved_callback(AtkText* self, gint p0,void* d
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Text_signal_text_caret_moved_info =
+const Glib::SignalProxyInfo Text_signal_text_caret_moved_info =
 {
   "text_caret_moved",
   (GCallback) &Text_signal_text_caret_moved_callback,
@@ -188,7 +178,7 @@ static const Glib::SignalProxyInfo Text_signal_text_caret_moved_info =
 };
 
 
-static const Glib::SignalProxyInfo Text_signal_text_selection_changed_info =
+const Glib::SignalProxyInfo Text_signal_text_selection_changed_info =
 {
   "text_selection_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -196,14 +186,13 @@ static const Glib::SignalProxyInfo Text_signal_text_selection_changed_info =
 };
 
 
-static const Glib::SignalProxyInfo Text_signal_text_attributes_changed_info =
+const Glib::SignalProxyInfo Text_signal_text_attributes_changed_info =
 {
   "text_attributes_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -211,16 +200,16 @@ namespace Atk
 {
 
 
- Glib::ustring Attribute::get_name() const
+Glib::ustring Attribute::get_name() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->name);
 }
- 
- Glib::ustring Attribute::get_value() const
+
+Glib::ustring Attribute::get_value() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->value);
 }
- 
+
 
 } // namespace Atk
 
@@ -284,7 +273,6 @@ void Text_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_text = &get_text_vfunc_callback;
   klass->get_character_at_offset = &get_character_at_offset_vfunc_callback;
   klass->get_text_after_offset = &get_text_after_offset_vfunc_callback;
@@ -302,17 +290,12 @@ void Text_Class::iface_init_function(void* g_iface, void*)
   klass->remove_selection = &remove_selection_vfunc_callback;
   klass->set_selection = &set_selection_vfunc_callback;
   klass->set_caret_offset = &set_caret_offset_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->text_changed = &text_changed_callback;
   klass->text_caret_moved = &text_caret_moved_callback;
   klass->text_selection_changed = &text_selection_changed_callback;
   klass->text_attributes_changed = &text_attributes_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gchar* Text_Class::get_text_vfunc_callback(AtkText* self, gint start_offset, gint end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -325,21 +308,17 @@ gchar* Text_Class::get_text_vfunc_callback(AtkText* self, gint start_offset, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return g_strdup((obj->get_text_vfunc(start_offset
 , end_offset
 )).c_str());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -356,6 +335,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gchar* RType;
   return RType();
 }
+
 gunichar Text_Class::get_character_at_offset_vfunc_callback(AtkText* self, gint offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -368,20 +348,16 @@ gunichar Text_Class::get_character_at_offset_vfunc_callback(AtkText* self, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_character_at_offset_vfunc(offset
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -398,6 +374,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gunichar RType;
   return RType();
 }
+
 gchar* Text_Class::get_text_after_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -410,23 +387,19 @@ gchar* Text_Class::get_text_after_offset_vfunc_callback(AtkText* self, gint offs
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return g_strdup((obj->get_text_after_offset_vfunc(offset
 , ((TextBoundary)(boundary_type))
 , *(start_offset)
 , *(end_offset)
 )).c_str());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -443,6 +416,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gchar* RType;
   return RType();
 }
+
 gchar* Text_Class::get_text_at_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -455,23 +429,19 @@ gchar* Text_Class::get_text_at_offset_vfunc_callback(AtkText* self, gint offset,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return g_strdup((obj->get_text_at_offset_vfunc(offset
 , ((TextBoundary)(boundary_type))
 , *(start_offset)
 , *(end_offset)
 )).c_str());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -488,6 +458,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gchar* RType;
   return RType();
 }
+
 gchar* Text_Class::get_text_before_offset_vfunc_callback(AtkText* self, gint offset, AtkTextBoundary boundary_type, gint* start_offset, gint* end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -500,23 +471,19 @@ gchar* Text_Class::get_text_before_offset_vfunc_callback(AtkText* self, gint off
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return g_strdup((obj->get_text_before_offset_vfunc(offset
 , ((TextBoundary)(boundary_type))
 , *(start_offset)
 , *(end_offset)
 )).c_str());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -533,6 +500,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gchar* RType;
   return RType();
 }
+
 gint Text_Class::get_caret_offset_vfunc_callback(AtkText* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -545,19 +513,15 @@ gint Text_Class::get_caret_offset_vfunc_callback(AtkText* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_caret_offset_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -574,6 +538,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 void Text_Class::get_character_extents_vfunc_callback(AtkText* self, gint offset, gint* x, gint* y, gint* width, gint* height, AtkCoordType coords)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -586,10 +551,8 @@ void Text_Class::get_character_extents_vfunc_callback(AtkText* self, gint offset
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_character_extents_vfunc(offset
 , *(x)
@@ -598,13 +561,11 @@ void Text_Class::get_character_extents_vfunc_callback(AtkText* self, gint offset
 , *(height)
 , ((CoordType)(coords))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -618,6 +579,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_character_extents)(self, offset, x, y, width, height, coords);
   }
 }
+
 AtkAttributeSet* Text_Class::get_run_attributes_vfunc_callback(AtkText* self, gint offset, gint* start_offset, gint* end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -630,22 +592,18 @@ AtkAttributeSet* Text_Class::get_run_attributes_vfunc_callback(AtkText* self, gi
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_run_attributes_vfunc(offset
 , *(start_offset)
 , *(end_offset)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -662,6 +620,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkAttributeSet* RType;
   return RType();
 }
+
 AtkAttributeSet* Text_Class::get_default_attributes_vfunc_callback(AtkText* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -674,19 +633,15 @@ AtkAttributeSet* Text_Class::get_default_attributes_vfunc_callback(AtkText* self
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_default_attributes_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -703,6 +658,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef AtkAttributeSet* RType;
   return RType();
 }
+
 gint Text_Class::get_character_count_vfunc_callback(AtkText* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -715,19 +671,15 @@ gint Text_Class::get_character_count_vfunc_callback(AtkText* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_character_count_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -744,6 +696,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Text_Class::get_offset_at_point_vfunc_callback(AtkText* self, gint x, gint y, AtkCoordType coords)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -756,22 +709,18 @@ gint Text_Class::get_offset_at_point_vfunc_callback(AtkText* self, gint x, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_offset_at_point_vfunc(x
 , y
 , ((CoordType)(coords))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -788,6 +737,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gint Text_Class::get_n_selections_vfunc_callback(AtkText* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -800,19 +750,15 @@ gint Text_Class::get_n_selections_vfunc_callback(AtkText* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_selections_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -829,6 +775,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 gchar* Text_Class::get_selection_vfunc_callback(AtkText* self, gint selection_num, gint* start_offset, gint* end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -841,22 +788,18 @@ gchar* Text_Class::get_selection_vfunc_callback(AtkText* self, gint selection_nu
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return g_strdup((obj->get_selection_vfunc(selection_num
 , *(start_offset)
 , *(end_offset)
 )).c_str());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -873,6 +816,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gchar* RType;
   return RType();
 }
+
 gboolean Text_Class::add_selection_vfunc_callback(AtkText* self, gint start_offset, gint end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -885,21 +829,17 @@ gboolean Text_Class::add_selection_vfunc_callback(AtkText* self, gint start_offs
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->add_selection_vfunc(start_offset
 , end_offset
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -916,6 +856,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Text_Class::remove_selection_vfunc_callback(AtkText* self, gint selection_num)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -928,20 +869,16 @@ gboolean Text_Class::remove_selection_vfunc_callback(AtkText* self, gint selecti
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->remove_selection_vfunc(selection_num
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -958,6 +895,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Text_Class::set_selection_vfunc_callback(AtkText* self, gint selection_num, gint start_offset, gint end_offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -970,22 +908,18 @@ gboolean Text_Class::set_selection_vfunc_callback(AtkText* self, gint selection_
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_selection_vfunc(selection_num
 , start_offset
 , end_offset
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1002,6 +936,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Text_Class::set_caret_offset_vfunc_callback(AtkText* self, gint offset)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1014,20 +949,16 @@ gboolean Text_Class::set_caret_offset_vfunc_callback(AtkText* self, gint offset)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_caret_offset_vfunc(offset
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1044,9 +975,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Text_Class::text_changed_callback(AtkText* self, gint p0, gint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1059,21 +989,17 @@ void Text_Class::text_changed_callback(AtkText* self, gint p0, gint p1)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_text_changed(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1087,6 +1013,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->text_changed)(self, p0, p1);
   }
 }
+
 void Text_Class::text_caret_moved_callback(AtkText* self, gint p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1099,20 +1026,16 @@ void Text_Class::text_caret_moved_callback(AtkText* self, gint p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_text_caret_moved(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1126,6 +1049,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->text_caret_moved)(self, p0);
   }
 }
+
 void Text_Class::text_selection_changed_callback(AtkText* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1138,19 +1062,15 @@ void Text_Class::text_selection_changed_callback(AtkText* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_text_selection_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1164,6 +1084,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->text_selection_changed)(self);
   }
 }
+
 void Text_Class::text_attributes_changed_callback(AtkText* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1176,19 +1097,15 @@ void Text_Class::text_attributes_changed_callback(AtkText* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_text_attributes_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1202,7 +1119,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->text_attributes_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Text_Class::wrap_new(GObject* object)
@@ -1276,7 +1192,7 @@ int Text::get_caret_offset() const
 
 void Text::get_character_extents(int offset, int& x, int& y, int& width, int& height, CoordType coords) const
 {
-atk_text_get_character_extents(const_cast<AtkText*>(gobj()), offset, &x, &y, &width, &height, ((AtkCoordType)(coords))); 
+  atk_text_get_character_extents(const_cast<AtkText*>(gobj()), offset, &x, &y, &width, &height, ((AtkCoordType)(coords)));
 }
 
 AttributeSet Text::get_run_attributes(int offset, int& start_offset, int& end_offset) const
@@ -1331,7 +1247,7 @@ bool Text::set_caret_offset(int offset)
 
 void Text::get_range_extents(int start_offset, int end_offset, CoordType coord_type, Rectangle& rect)
 {
-atk_text_get_range_extents(gobj(), start_offset, end_offset, ((AtkCoordType)(coord_type)), &(rect)); 
+  atk_text_get_range_extents(gobj(), start_offset, end_offset, ((AtkCoordType)(coord_type)), &(rect));
 }
 
 AtkTextRange** Text::get_bounded_ranges(const Rectangle& rect, CoordType coord_type, TextClipType x_clip_type, TextClipType y_clip_type)
@@ -1345,26 +1261,22 @@ Glib::SignalProxy2< void,int,int > Text::signal_text_changed()
   return Glib::SignalProxy2< void,int,int >(this, &Text_signal_text_changed_info);
 }
 
-
 Glib::SignalProxy1< void,int > Text::signal_text_caret_moved()
 {
   return Glib::SignalProxy1< void,int >(this, &Text_signal_text_caret_moved_info);
 }
 
-
 Glib::SignalProxy0< void > Text::signal_text_selection_changed()
 {
   return Glib::SignalProxy0< void >(this, &Text_signal_text_selection_changed_info);
 }
 
-
 Glib::SignalProxy0< void > Text::signal_text_attributes_changed()
 {
   return Glib::SignalProxy0< void >(this, &Text_signal_text_attributes_changed_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Atk::Text::on_text_changed(int position, int length)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1375,6 +1287,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->text_changed)
     (*base->text_changed)(gobj(),position,length);
 }
+
 void Atk::Text::on_text_caret_moved(int location)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1385,6 +1298,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->text_caret_moved)
     (*base->text_caret_moved)(gobj(),location);
 }
+
 void Atk::Text::on_text_selection_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1395,6 +1309,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->text_selection_changed)
     (*base->text_selection_changed)(gobj());
 }
+
 void Atk::Text::on_text_attributes_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1405,9 +1320,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->text_attributes_changed)
     (*base->text_attributes_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 Glib::ustring Atk::Text::get_text_vfunc(int start_offset, int end_offset) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1421,6 +1335,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::ustring RType;
   return RType();
 }
+
 gunichar Atk::Text::get_character_at_offset_vfunc(int offset) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1434,6 +1349,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef gunichar RType;
   return RType();
 }
+
 Glib::ustring Atk::Text::get_text_after_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1447,6 +1363,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::ustring RType;
   return RType();
 }
+
 Glib::ustring Atk::Text::get_text_at_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1460,6 +1377,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::ustring RType;
   return RType();
 }
+
 Glib::ustring Atk::Text::get_text_before_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1473,6 +1391,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::ustring RType;
   return RType();
 }
+
 int Atk::Text::get_caret_offset_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1486,6 +1405,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 void Atk::Text::get_character_extents_vfunc(int offset, int& x, int& y, int& width, int& height, CoordType coords) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1496,6 +1416,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_character_extents)
     (*base->get_character_extents)(const_cast<AtkText*>(gobj()),offset,&x,&y,&width,&height,((AtkCoordType)(coords)));
 }
+
 AtkAttributeSet* Atk::Text::get_run_attributes_vfunc(int offset, int& start_offset, int& end_offset) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1509,6 +1430,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef AtkAttributeSet* RType;
   return RType();
 }
+
 AtkAttributeSet* Atk::Text::get_default_attributes_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1522,6 +1444,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef AtkAttributeSet* RType;
   return RType();
 }
+
 int Atk::Text::get_character_count_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1535,6 +1458,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Text::get_offset_at_point_vfunc(int x, int y, CoordType coords) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1548,6 +1472,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 int Atk::Text::get_n_selections_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1561,6 +1486,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 Glib::ustring Atk::Text::get_selection_vfunc(int selection_num, int& start_offset, int& end_offset) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1574,6 +1500,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::ustring RType;
   return RType();
 }
+
 bool Atk::Text::add_selection_vfunc(int start_offset, int end_offset) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1587,6 +1514,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Text::remove_selection_vfunc(int selection_num) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1600,6 +1528,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Text::set_selection_vfunc(int selection_num, int start_offset, int end_offset) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1613,6 +1542,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Atk::Text::set_caret_offset_vfunc(int offset) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1626,7 +1556,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/text.h b/libs/gtkmm2/atk/atkmm/text.h
index 01d10f4658..86dee7ee39 100644
--- a/libs/gtkmm2/atk/atkmm/text.h
+++ b/libs/gtkmm2/atk/atkmm/text.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_TEXT_H
 #define _ATKMM_TEXT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -63,9 +62,9 @@ public:
 
   void swap(Attribute& other);
 
-   Glib::ustring get_name() const;
-    Glib::ustring get_value() const;
- 
+  Glib::ustring get_name() const;
+  Glib::ustring get_value() const;
+
   /// Provides access to the underlying C GObject.
   AtkAttribute*       gobj()       { return &gobject_; }
 
@@ -375,8 +374,7 @@ public:
    * @param offset Position.
    * @param boundary_type An Atk::TextBoundary.
    * @param start_offset The start offset of the returned string.
-   * @param end_offset The offset of the first character after the 
-   * returned substring.
+   * @param end_offset The end offset of the returned string.
    * @return The text after @a offset  bounded by the specified @a boundary_type .
    */
   Glib::ustring get_text_after_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
@@ -428,8 +426,7 @@ public:
    * @param offset Position.
    * @param boundary_type An Atk::TextBoundary.
    * @param start_offset The start offset of the returned string.
-   * @param end_offset The offset of the first character after the 
-   * returned substring.
+   * @param end_offset The end offset of the returned string.
    * @return The text at @a offset  bounded by the specified @a boundary_type .
    */
   Glib::ustring get_text_at_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
@@ -479,8 +476,7 @@ public:
    * @param offset Position.
    * @param boundary_type An Atk::TextBoundary.
    * @param start_offset The start offset of the returned string.
-   * @param end_offset The offset of the first character after the 
-   * returned substring.
+   * @param end_offset The end offset of the returned string.
    * @return The text before @a offset  bounded by the specified @a boundary_type .
    */
   Glib::ustring get_text_before_offset(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
@@ -553,15 +549,14 @@ public:
    * of the text region is assigned the number 0, etc.  Note that adding,
    * moving or deleting a selected region can change the numbering.
    * @param start_offset Passes back the start position of the selected region.
-   * @param end_offset Passes back the end position of (e.g. offset immediately past) 
-   * the selected region.
+   * @param end_offset Passes back the end position of the selected region.
    * @return The selected text.
    */
   Glib::ustring get_selection(int selection_num, int& start_offset, int& end_offset) const;
   
   /** Adds a selection bounded by the specified offsets.
    * @param start_offset The start position of the selected region.
-   * @param end_offset The offset of the first character after the selected region.
+   * @param end_offset The end position of the selected region.
    * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
    */
   bool add_selection(int start_offset, int end_offset);
@@ -583,8 +578,7 @@ public:
    * of the text region is assigned the number 0, etc.  Note that adding,
    * moving or deleting a selected region can change the numbering.
    * @param start_offset The new start position of the selection.
-   * @param end_offset The new end position of (e.g. offset immediately past) 
-   * the selection.
+   * @param end_offset The new end position of the selection.
    * @return <tt>true</tt> if success, <tt>false</tt> otherwise.
    */
   bool set_selection(int selection_num, int start_offset, int end_offset);
@@ -622,109 +616,38 @@ public:
                                                  TextClipType x_clip_type, TextClipType y_clip_type);
                                                            
 
-/**
-   * @par Prototype:
-   * <tt>void %text_changed(int position, int length)</tt>
-   */
-
   Glib::SignalProxy2< void,int,int > signal_text_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %text_caret_moved(int location)</tt>
-   */
-
   Glib::SignalProxy1< void,int > signal_text_caret_moved();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %text_selection_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_text_selection_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %text_attributes_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_text_attributes_changed();
 
 
 protected:
  
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::ustring get_text_vfunc(int start_offset, int end_offset) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual gunichar get_character_at_offset_vfunc(int offset) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::ustring get_text_after_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::ustring get_text_at_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::ustring get_text_before_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_caret_offset_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_character_extents_vfunc(int offset, int& x, int& y, int& width, int& height, CoordType coords) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual AtkAttributeSet* get_run_attributes_vfunc(int offset, int& start_offset, int& end_offset) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual AtkAttributeSet* get_default_attributes_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_character_count_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_offset_at_point_vfunc(int x, int y, CoordType coords) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_selections_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::ustring get_selection_vfunc(int selection_num, int& start_offset, int& end_offset) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool add_selection_vfunc(int start_offset, int end_offset);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool remove_selection_vfunc(int selection_num);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_selection_vfunc(int selection_num, int start_offset, int end_offset);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_caret_offset_vfunc(int offset);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual Glib::ustring get_text_vfunc(int start_offset, int end_offset) const;
+    virtual gunichar get_character_at_offset_vfunc(int offset) const;
+    virtual Glib::ustring get_text_after_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+    virtual Glib::ustring get_text_at_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+    virtual Glib::ustring get_text_before_offset_vfunc(int offset, TextBoundary boundary_type, int& start_offset, int& end_offset) const;
+    virtual int get_caret_offset_vfunc() const;
+    virtual void get_character_extents_vfunc(int offset, int& x, int& y, int& width, int& height, CoordType coords) const;
+    virtual AtkAttributeSet* get_run_attributes_vfunc(int offset, int& start_offset, int& end_offset) const;
+    virtual AtkAttributeSet* get_default_attributes_vfunc() const;
+    virtual int get_character_count_vfunc() const;
+    virtual int get_offset_at_point_vfunc(int x, int y, CoordType coords) const;
+    virtual int get_n_selections_vfunc() const;
+    virtual Glib::ustring get_selection_vfunc(int selection_num, int& start_offset, int& end_offset) const;
+    virtual bool add_selection_vfunc(int start_offset, int end_offset);
+    virtual bool remove_selection_vfunc(int selection_num);
+    virtual bool set_selection_vfunc(int selection_num, int start_offset, int end_offset);
+    virtual bool set_caret_offset_vfunc(int offset);
   
   //TODO: Add get_range_extents(), and get_bounded_ranges() vfuncs when we can break ABI.
 
@@ -733,21 +656,15 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_text_changed(int position, int length);
   virtual void on_text_caret_moved(int location);
   virtual void on_text_selection_changed();
   virtual void on_text_attributes_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -766,6 +683,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_TEXT_H */
 
diff --git a/libs/gtkmm2/atk/atkmm/value.cc b/libs/gtkmm2/atk/atkmm/value.cc
index 3a92b2df12..eeff7dfd2f 100644
--- a/libs/gtkmm2/atk/atkmm/value.cc
+++ b/libs/gtkmm2/atk/atkmm/value.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <atkmm/value.h>
 #include <atkmm/private/value_p.h>
 
@@ -73,18 +72,12 @@ void Value_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_current_value = &get_current_value_vfunc_callback;
   klass->get_maximum_value = &get_maximum_value_vfunc_callback;
   klass->get_minimum_value = &get_minimum_value_vfunc_callback;
   klass->set_current_value = &set_current_value_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Value_Class::get_current_value_vfunc_callback(AtkValue* self, GValue* value)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -97,20 +90,16 @@ void Value_Class::get_current_value_vfunc_callback(AtkValue* self, GValue* value
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_current_value_vfunc(*reinterpret_cast<Glib::ValueBase*>(value)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -124,6 +113,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_current_value)(self, value);
   }
 }
+
 void Value_Class::get_maximum_value_vfunc_callback(AtkValue* self, GValue* value)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -136,20 +126,16 @@ void Value_Class::get_maximum_value_vfunc_callback(AtkValue* self, GValue* value
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_maximum_value_vfunc(*reinterpret_cast<Glib::ValueBase*>(value)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -163,6 +149,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_maximum_value)(self, value);
   }
 }
+
 void Value_Class::get_minimum_value_vfunc_callback(AtkValue* self, GValue* value)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -175,20 +162,16 @@ void Value_Class::get_minimum_value_vfunc_callback(AtkValue* self, GValue* value
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_minimum_value_vfunc(*reinterpret_cast<Glib::ValueBase*>(value)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -202,6 +185,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_minimum_value)(self, value);
   }
 }
+
 gboolean Value_Class::set_current_value_vfunc_callback(AtkValue* self, const GValue* value)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -214,20 +198,16 @@ gboolean Value_Class::set_current_value_vfunc_callback(AtkValue* self, const GVa
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->set_current_value_vfunc(*reinterpret_cast<const Glib::ValueBase*>(value)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -244,10 +224,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Value_Class::wrap_new(GObject* object)
@@ -292,17 +268,17 @@ GType Value::get_base_type()
 
 void Value::get_current_value(Glib::ValueBase& value) const
 {
-atk_value_get_current_value(const_cast<AtkValue*>(gobj()), (value).gobj()); 
+  atk_value_get_current_value(const_cast<AtkValue*>(gobj()), (value).gobj());
 }
 
 void Value::get_maximum_value(Glib::ValueBase& value) const
 {
-atk_value_get_maximum_value(const_cast<AtkValue*>(gobj()), (value).gobj()); 
+  atk_value_get_maximum_value(const_cast<AtkValue*>(gobj()), (value).gobj());
 }
 
 void Value::get_minimum_value(Glib::ValueBase& value) const
 {
-atk_value_get_minimum_value(const_cast<AtkValue*>(gobj()), (value).gobj()); 
+  atk_value_get_minimum_value(const_cast<AtkValue*>(gobj()), (value).gobj());
 }
 
 bool Value::set_current_value(const Glib::ValueBase& value)
@@ -311,10 +287,6 @@ bool Value::set_current_value(const Glib::ValueBase& value)
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Atk::Value::get_current_value_vfunc(Glib::ValueBase& value) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -325,6 +297,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_current_value)
     (*base->get_current_value)(const_cast<AtkValue*>(gobj()),(value).gobj());
 }
+
 void Atk::Value::get_maximum_value_vfunc(Glib::ValueBase& value) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -335,6 +308,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_maximum_value)
     (*base->get_maximum_value)(const_cast<AtkValue*>(gobj()),(value).gobj());
 }
+
 void Atk::Value::get_minimum_value_vfunc(Glib::ValueBase& value) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -345,6 +319,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_minimum_value)
     (*base->get_minimum_value)(const_cast<AtkValue*>(gobj()),(value).gobj());
 }
+
 bool Atk::Value::set_current_value_vfunc(const Glib::ValueBase& value) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -358,7 +333,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Atk
diff --git a/libs/gtkmm2/atk/atkmm/value.h b/libs/gtkmm2/atk/atkmm/value.h
index 92f2e487fd..25615dd92e 100644
--- a/libs/gtkmm2/atk/atkmm/value.h
+++ b/libs/gtkmm2/atk/atkmm/value.h
@@ -3,7 +3,6 @@
 #ifndef _ATKMM_VALUE_H
 #define _ATKMM_VALUE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -121,38 +120,21 @@ public:
   bool set_current_value(const Glib::ValueBase& value);
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_current_value_vfunc(Glib::ValueBase& value) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_maximum_value_vfunc(Glib::ValueBase& value) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_minimum_value_vfunc(Glib::ValueBase& value) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool set_current_value_vfunc(const Glib::ValueBase& value);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void get_current_value_vfunc(Glib::ValueBase& value) const;
+    virtual void get_maximum_value_vfunc(Glib::ValueBase& value) const;
+    virtual void get_minimum_value_vfunc(Glib::ValueBase& value) const;
+    virtual bool set_current_value_vfunc(const Glib::ValueBase& value);
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -171,6 +153,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _ATKMM_VALUE_H */
 
diff --git a/libs/gtkmm2/gdk/.DS_Store b/libs/gtkmm2/gdk/.DS_Store
new file mode 100644
index 0000000000..5008ddfcf5
--- /dev/null
+++ b/libs/gtkmm2/gdk/.DS_Store
diff --git a/libs/gtkmm2/gdk/SConscript b/libs/gtkmm2/gdk/SConscript
index dbd8c0845f..6ea5c7cfef 100644
--- a/libs/gtkmm2/gdk/SConscript
+++ b/libs/gtkmm2/gdk/SConscript
@@ -8,14 +8,8 @@ gdkmm2_files = glob.glob('gdkmm/*.cc')
 
 Import('env libraries install_prefix')
 gdkmm2 = env.Copy()
-gdkmm2.Merge([ libraries['glibmm2'], 
-               libraries['gtk2'], 
-               libraries['sigc2'], 
-               libraries['pangomm'], 
-               libraries['cairomm'] ])
-
+gdkmm2.Merge([libraries['glibmm2'], libraries['gtk2'], libraries['sigc2'], libraries['pangomm']])
 gdkmm2.Append(CXXFLAGS="-Ilibs/gtkmm2/gtk")
-gdkmm2.Append(CXXFLAGS="-DGDKMM_DISABLE_DEPRECATED")
 
 libgdkmm2 = gdkmm2.SharedLibrary('gdkmm2', gdkmm2_files)
 Default(libgdkmm2)
diff --git a/libs/gtkmm2/gdk/gdkmm/bitmap.cc b/libs/gtkmm2/gdk/gdkmm/bitmap.cc
index d50b48945e..27063537a6 100644
--- a/libs/gtkmm2/gdk/gdkmm/bitmap.cc
+++ b/libs/gtkmm2/gdk/gdkmm/bitmap.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/bitmap.h>
 #include <gdkmm/private/bitmap_p.h>
 
diff --git a/libs/gtkmm2/gdk/gdkmm/bitmap.h b/libs/gtkmm2/gdk/gdkmm/bitmap.h
index 4f6728e721..57dc9fb087 100644
--- a/libs/gtkmm2/gdk/gdkmm/bitmap.h
+++ b/libs/gtkmm2/gdk/gdkmm/bitmap.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_BITMAP_H
 #define _GDKMM_BITMAP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
diff --git a/libs/gtkmm2/gdk/gdkmm/color.cc b/libs/gtkmm2/gdk/gdkmm/color.cc
index 1d95cff54e..06c8e70cf5 100644
--- a/libs/gtkmm2/gdk/gdkmm/color.cc
+++ b/libs/gtkmm2/gdk/gdkmm/color.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/color.h>
 #include <gdkmm/private/color_p.h>
 
@@ -152,14 +151,10 @@ bool Color::set(const Glib::ustring& value)
   return gdk_color_parse(value.c_str(), gobj());
 }
 
-#ifndef GDKMM_DISABLE_DEPRECATED
-
 bool Color::parse(const Glib::ustring& spec)
 {
   return set(spec);
 }
-#endif // GDKMM_DISABLE_DEPRECATED
-
 
 gushort Color::get_red() const
 {
diff --git a/libs/gtkmm2/gdk/gdkmm/color.h b/libs/gtkmm2/gdk/gdkmm/color.h
index 167152d1fa..c40ff67f25 100644
--- a/libs/gtkmm2/gdk/gdkmm/color.h
+++ b/libs/gtkmm2/gdk/gdkmm/color.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_COLOR_H
 #define _GDKMM_COLOR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -127,14 +126,12 @@ public:
   */
   bool set(const Glib::ustring& value);
 
-  #ifndef GDKMM_DISABLE_DEPRECATED
-
+  #ifndef GDKMM_DEPRECATED
   /** 
    * @deprecated See set().
    */
   bool parse(const Glib::ustring& spec);
-  #endif // GDKMM_DISABLE_DEPRECATED
-
+  #endif //GDKMM_DEPRECATED
 
   /** Get the red component of the color.
    * @result The red component of the color.
@@ -273,6 +270,5 @@ class Value<Gdk::Color> : public Glib::Value_Boxed<Gdk::Color>
 
 } // namespace Glib
 
-
 #endif /* _GDKMM_COLOR_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/colormap.cc b/libs/gtkmm2/gdk/gdkmm/colormap.cc
index 64670009b3..af2d64aec1 100644
--- a/libs/gtkmm2/gdk/gdkmm/colormap.cc
+++ b/libs/gtkmm2/gdk/gdkmm/colormap.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/colormap.h>
 #include <gdkmm/private/colormap_p.h>
 
@@ -35,26 +34,7 @@ Colormap::Colormap(const Glib::RefPtr<Visual>& visual, bool allocate)
 : Glib::Object( G_OBJECT( gdk_colormap_new(visual->gobj(), (gboolean)allocate) ) )
   {}
 
-#ifndef GDKMM_DISABLE_DEPRECATED
-
-int Colormap::alloc_colors(ArrayHandle_Color& colors, int ncolors, bool writeable, bool best_match, Glib::ArrayHandle<bool>& success)
-{
-  return gdk_colormap_alloc_colors(gobj(), const_cast<GdkColor*>(colors.data()), ncolors, static_cast<int>(writeable), static_cast<int>(best_match), (gboolean*)(success.data()));
-}
-
-void Colormap::free_colors(Color& colors, int ncolors)
-{
-  gdk_colormap_free_colors(gobj(), (colors).gobj(), ncolors);
-}
-#endif // GDKMM_DISABLE_DEPRECATED
-
-
-void Colormap::free_color(Color& color)
-{
-  gdk_colormap_free_colors(gobj(), color.gobj(), 1);
-}
-
-} // namespace Gdk
+} /* namespace Gdk */
 
 
 namespace
@@ -105,19 +85,8 @@ void Colormap_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Colormap_Class::wrap_new(GObject* object)
 {
@@ -174,53 +143,65 @@ Glib::RefPtr<Colormap> Colormap::get_system()
   return retvalue;
 }
 
+int Colormap::alloc_colors(ArrayHandle_Color& colors, int ncolors, bool writeable, bool best_match, Glib::ArrayHandle<bool>& success)
+{
+  return gdk_colormap_alloc_colors(gobj(), const_cast<GdkColor*>(colors.data()), ncolors, static_cast<int>(writeable), static_cast<int>(best_match), (gboolean*)(success.data()));
+}
 
 bool Colormap::alloc_color(Color& color, bool writeable, bool best_match)
 {
   return gdk_colormap_alloc_color(gobj(), (color).gobj(), static_cast<int>(writeable), static_cast<int>(best_match));
 }
 
+void Colormap::free_colors(Color& colors, int ncolors)
+{
+  gdk_colormap_free_colors(gobj(), (colors).gobj(), ncolors);
+}
+
 void Colormap::query_color(gulong pixel, Color& result)
 {
-gdk_colormap_query_color(gobj(), pixel, (result).gobj()); 
+  gdk_colormap_query_color(gobj(), pixel, (result).gobj());
 }
 
 Glib::RefPtr<Visual> Colormap::get_visual()
 {
 
   Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_colormap_get_visual(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Visual> Colormap::get_visual() const
 {
-  return const_cast<Colormap*>(this)->get_visual();
+
+  Glib::RefPtr<const Visual> retvalue = Glib::wrap(gdk_colormap_get_visual(const_cast<GdkColormap*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Screen> Colormap::get_screen()
 {
 
   Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_colormap_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Screen> Colormap::get_screen() const
 {
-  return const_cast<Colormap*>(this)->get_screen();
-}
 
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_colormap_get_screen(const_cast<GdkColormap*>(gobj())));
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/colormap.h b/libs/gtkmm2/gdk/gdkmm/colormap.h
index 2d2a4cd92e..5f73acbf59 100644
--- a/libs/gtkmm2/gdk/gdkmm/colormap.h
+++ b/libs/gtkmm2/gdk/gdkmm/colormap.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_COLORMAP_H
 #define _GDKMM_COLORMAP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -115,18 +114,27 @@ public:
 
   //_WRAP_METHOD(void change(int ncolors), gdk_colormap_change)
 
-  #ifndef GDKMM_DISABLE_DEPRECATED
+  // Both 'GdkColor* colors' and 'gboolean* success' are _array_ output arguments.
+ 
 
-  ///@deprecated Use alloc_color().
+  /** Allocates colors from a colormap.
+   * @param colors The color values to allocate. On return, the pixel
+   * values for allocated colors will be filled in.
+   * @param ncolors The number of colors in @a colors .
+   * @param writeable If <tt>true</tt>, the colors are allocated writeable
+   * (their values can later be changed using gdk_color_change()).
+   * Writeable colors cannot be shared between applications.
+   * @param best_match If <tt>true</tt>, GDK will attempt to do matching against
+   * existing colors if the colors cannot be allocated as requested.
+   * @param success An array of length @a ncolors . On return, this
+   * indicates whether the corresponding color in @a colors  was
+   * successfully allocated or not.
+   * @return The number of colors that were not successfully 
+   * allocated.
+   */
   int alloc_colors(ArrayHandle_Color& colors, int ncolors, bool writeable, bool best_match, Glib::ArrayHandle<bool>& success);
-  
 
-  ///@deprecated Use free_color()
-  void free_colors(Color& colors, int ncolors);
   
-  #endif // GDKMM_DISABLE_DEPRECATED
-
-
   /** Allocates a single color from a colormap.
    * @param color The color to allocate. On return the
    * &lt;structfield&gt;pixel&lt;/structfield&gt; field will be
@@ -139,8 +147,12 @@ public:
    * @return <tt>true</tt> if the allocation succeeded.
    */
   bool alloc_color(Color& color, bool writeable = false, bool best_match = true);
-  void free_color(Color& color);
-
+  
+  /** Frees previously allocated colors.
+   * @param colors The colors to free.
+   * @param ncolors The number of colors in @a colors .
+   */
+  void free_colors(Color& colors, int ncolors);
   
   /** Locates the RGB color in @a colormap  corresponding to the given
    * hardware pixel @a pixel . @a pixel  must be a valid pixel in the
@@ -172,14 +184,14 @@ public:
   /** Gets the screen for which this colormap was created.
    * @return The screen for which this colormap was created.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Screen> get_screen();
   
   /** Gets the screen for which this colormap was created.
    * @return The screen for which this colormap was created.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Screen> get_screen() const;
   
@@ -188,17 +200,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/cursor.cc b/libs/gtkmm2/gdk/gdkmm/cursor.cc
index 0f449a6108..1a8e639472 100644
--- a/libs/gtkmm2/gdk/gdkmm/cursor.cc
+++ b/libs/gtkmm2/gdk/gdkmm/cursor.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/cursor.h>
 #include <gdkmm/private/cursor_p.h>
 
@@ -55,12 +54,7 @@ Cursor::Cursor(const Glib::RefPtr<Display>& display, CursorType cursor_type)
 Cursor::Cursor(const Glib::RefPtr<Display>& display, const Glib::RefPtr<Pixbuf>& pixbuf, int x, int y)
 {
   gobject_ = gdk_cursor_new_from_pixbuf(display->gobj(), pixbuf->gobj(), x, y);
-}
-
-Cursor::Cursor(const Glib::RefPtr<Display>& display, const Glib::ustring& name)
-{
-  gobject_ = gdk_cursor_new_from_name(display->gobj(), name.c_str());
-}      
+}          
 
 } //namespace Gdk
 
@@ -145,25 +139,20 @@ Glib::RefPtr<Display> Cursor::get_display()
 {
 
   Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_cursor_get_display(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Display> Cursor::get_display() const
 {
-  return const_cast<Cursor*>(this)->get_display();
-}
 
-Glib::RefPtr<Gdk::Pixbuf> Cursor::get_image()
-{
-  return Glib::wrap(gdk_cursor_get_image(gobj()));
-}
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_cursor_get_display(const_cast<GdkCursor*>(gobj())));
 
-Glib::RefPtr<const Gdk::Pixbuf> Cursor::get_image() const
-{
-  return const_cast<Cursor*>(this)->get_image();
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 
diff --git a/libs/gtkmm2/gdk/gdkmm/cursor.h b/libs/gtkmm2/gdk/gdkmm/cursor.h
index 19b6d6054b..59ab2f827f 100644
--- a/libs/gtkmm2/gdk/gdkmm/cursor.h
+++ b/libs/gtkmm2/gdk/gdkmm/cursor.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_CURSOR_H
 #define _GDKMM_CURSOR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -196,46 +195,22 @@ public:
          int x, int y);
   explicit Cursor(const Glib::RefPtr<Display>& display, CursorType cursor_type);
   Cursor(const Glib::RefPtr<Display>& display, const Glib::RefPtr<Pixbuf>& pixbuf, int x, int y);
-  explicit Cursor(const Glib::RefPtr<Display>& display, const Glib::ustring& name);
 
   
   /** Returns the display on which the Gdk::Cursor is defined.
    * @return The Gdk::Display associated to @a cursor 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Display> get_display();
   
   /** Returns the display on which the Gdk::Cursor is defined.
    * @return The Gdk::Display associated to @a cursor 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Display> get_display() const;
 
-  
-  /** Returns a Gdk::Pixbuf with the image used to display the cursor.
-   * 
-   * Note that depending on the capabilities of the windowing system and 
-   * on the cursor, GDK may not be able to obtain the image data. In this 
-   * case, <tt>0</tt> is returned.
-   * @return A Gdk::Pixbuf representing @a cursor , or <tt>0</tt>
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<Gdk::Pixbuf> get_image();
-  
-  /** Returns a Gdk::Pixbuf with the image used to display the cursor.
-   * 
-   * Note that depending on the capabilities of the windowing system and 
-   * on the cursor, GDK may not be able to obtain the image data. In this 
-   * case, <tt>0</tt> is returned.
-   * @return A Gdk::Pixbuf representing @a cursor , or <tt>0</tt>
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<const Gdk::Pixbuf> get_image() const;
-
 
 };
 
@@ -272,6 +247,5 @@ class Value<Gdk::Cursor> : public Glib::Value_Boxed<Gdk::Cursor>
 
 } // namespace Glib
 
-
 #endif /* _GDKMM_CURSOR_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/device.cc b/libs/gtkmm2/gdk/gdkmm/device.cc
index 5d29021169..78d223a363 100644
--- a/libs/gtkmm2/gdk/gdkmm/device.cc
+++ b/libs/gtkmm2/gdk/gdkmm/device.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/device.h>
 #include <gdkmm/private/device_p.h>
 
@@ -93,19 +92,8 @@ void Device_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Device_Class::wrap_new(GObject* object)
 {
@@ -157,7 +145,7 @@ Device::Device()
 
 void Device::set_source(InputSource source)
 {
-gdk_device_set_source(gobj(), ((GdkInputSource)(source))); 
+  gdk_device_set_source(gobj(), ((GdkInputSource)(source)));
 }
 
 bool Device::set_mode(InputMode mode)
@@ -167,17 +155,17 @@ bool Device::set_mode(InputMode mode)
 
 void Device::set_key(guint index_, guint keyval, ModifierType modifiers)
 {
-gdk_device_set_key(gobj(), index_, keyval, ((GdkModifierType)(modifiers))); 
+  gdk_device_set_key(gobj(), index_, keyval, ((GdkModifierType)(modifiers)));
 }
 
 void Device::set_axis_use(guint index_, AxisUse use)
 {
-gdk_device_set_axis_use(gobj(), index_, ((GdkAxisUse)(use))); 
+  gdk_device_set_axis_use(gobj(), index_, ((GdkAxisUse)(use)));
 }
 
 void Device::get_state(const Glib::RefPtr<Window>& window, double& axes, ModifierType& mask)
 {
-gdk_device_get_state(gobj(), Glib::unwrap(window), &(axes), ((GdkModifierType*) &(mask))); 
+  gdk_device_get_state(gobj(), Glib::unwrap(window), &(axes), ((GdkModifierType*) &(mask)));
 }
 
 bool Device::get_history(const Glib::RefPtr<Window>& window, guint32 start, guint32 stop, GdkTimeCoord**& events, int& n_events)
@@ -190,32 +178,25 @@ bool Device::get_axis(double& axes, AxisUse use, double& value) const
   return gdk_device_get_axis(const_cast<GdkDevice*>(gobj()), &(axes), ((GdkAxisUse)(use)), &(value));
 }
 
- Glib::ustring Device::get_name() const
+Glib::ustring Device::get_name() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->name);
 }
- 
- InputSource Device::get_source() const
+
+InputSource Device::get_source() const
 {
   return ((InputSource)(gobj()->source));
 }
- 
- InputMode Device::get_mode() const
+
+InputMode Device::get_mode() const
 {
   return ((InputMode)(gobj()->mode));
 }
- 
- bool Device::get_has_cursor() const
+
+bool Device::get_has_cursor() const
 {
   return gobj()->has_cursor;
 }
- 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/device.h b/libs/gtkmm2/gdk/gdkmm/device.h
index 2453396d73..c3146c0010 100644
--- a/libs/gtkmm2/gdk/gdkmm/device.h
+++ b/libs/gtkmm2/gdk/gdkmm/device.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_DEVICE_H
 #define _GDKMM_DEVICE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -199,23 +198,23 @@ public:
   /** Gets the name of this device.
    * @result The name of this device.
    */
-   Glib::ustring get_name() const;
-   
+  Glib::ustring get_name() const;
+  
   /** Gets the type of this device.
    * @result The type of this device.
    */
-   InputSource get_source() const;
- 
+  InputSource get_source() const;
+
   /** Gets the mode of this device.
    * @result The mode of this device.
    */
-   InputMode get_mode() const;
-     
+  InputMode get_mode() const;
+    
   /** Discover whether the pointer follows device motion.
    * @result true if the pointer follows device motion.
    */
-   bool get_has_cursor() const;
- 
+  bool get_has_cursor() const;
+
   //TODO: Add suitable accessor for the information in these fields. For now, people must use gobj() and access them directly.
   //gint num_axes	the length of the axes array.
   //GdkDeviceAxis *axes	an array of GdkDeviceAxis, describing the axes of this device.
@@ -228,17 +227,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/display.cc b/libs/gtkmm2/gdk/gdkmm/display.cc
index fe4318c328..ff3f528fff 100644
--- a/libs/gtkmm2/gdk/gdkmm/display.cc
+++ b/libs/gtkmm2/gdk/gdkmm/display.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/display.h>
 #include <gdkmm/private/display_p.h>
 
@@ -122,8 +121,7 @@ GdkDisplayPointerHooks*  Display::unset_pointer_hooks()
 namespace
 {
 
-
-static void Display_signal_closed_callback(GdkDisplay* self, gboolean p0,void* data)
+void Display_signal_closed_callback(GdkDisplay* self, gboolean p0,void* data)
 {
   using namespace Gdk;
   typedef sigc::slot< void,bool > SlotType;
@@ -131,31 +129,26 @@ static void Display_signal_closed_callback(GdkDisplay* self, gboolean p0,void* d
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Display_signal_closed_info =
+const Glib::SignalProxyInfo Display_signal_closed_info =
 {
   "closed",
   (GCallback) &Display_signal_closed_callback,
   (GCallback) &Display_signal_closed_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -202,18 +195,10 @@ void Display_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->closed = &closed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Display_Class::closed_callback(GdkDisplay* self, gboolean p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -226,20 +211,16 @@ void Display_Class::closed_callback(GdkDisplay* self, gboolean p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_closed(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -252,7 +233,6 @@ void Display_Class::closed_callback(GdkDisplay* self, gboolean p0)
       (*base->closed)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Display_Class::wrap_new(GObject* object)
@@ -313,7 +293,6 @@ Glib::RefPtr<Display> Display::open(const Glib::ustring& display_name)
   return retvalue;
 }
 
-
 Glib::ustring Display::get_name() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gdk_display_get_name(const_cast<GdkDisplay*>(gobj())));
@@ -328,40 +307,50 @@ Glib::RefPtr<Screen> Display::get_screen(int screen_num)
 {
 
   Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_display_get_screen(gobj(), screen_num));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Screen> Display::get_screen(int screen_num) const
 {
-  return const_cast<Display*>(this)->get_screen(screen_num);
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_display_get_screen(const_cast<GdkDisplay*>(gobj()), screen_num));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Screen> Display::get_default_screen()
 {
 
   Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_display_get_default_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Screen> Display::get_default_screen() const
 {
-  return const_cast<Display*>(this)->get_default_screen();
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_display_get_default_screen(const_cast<GdkDisplay*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Display::pointer_ungrab(guint32 timestamp)
 {
-gdk_display_pointer_ungrab(gobj(), timestamp); 
+  gdk_display_pointer_ungrab(gobj(), timestamp);
 }
 
 void Display::keyboard_ungrab(guint32 timestamp)
 {
-gdk_display_keyboard_ungrab(gobj(), timestamp); 
+  gdk_display_keyboard_ungrab(gobj(), timestamp);
 }
 
 bool Display::pointer_is_grabbed() const
@@ -371,27 +360,27 @@ bool Display::pointer_is_grabbed() const
 
 void Display::beep()
 {
-gdk_display_beep(gobj()); 
+  gdk_display_beep(gobj());
 }
 
 void Display::sync()
 {
-gdk_display_sync(gobj()); 
+  gdk_display_sync(gobj());
 }
 
 void Display::close()
 {
-gdk_display_close(gobj()); 
+  gdk_display_close(gobj());
 }
 
 Glib::ListHandle< Glib::RefPtr<Device> > Display::list_devices()
 {
-  return Glib::ListHandle< Glib::RefPtr<Device> >(gdk_display_list_devices(gobj()), Glib::OWNERSHIP_NONE);
+  return Glib::ListHandle< Glib::RefPtr<Device> >(gdk_display_list_devices(gobj()), Glib::OWNERSHIP_DEEP);
 }
 
 Glib::ListHandle< Glib::RefPtr<const Device> > Display::list_devices() const
 {
-  return Glib::ListHandle< Glib::RefPtr<const Device> >(gdk_display_list_devices(const_cast<GdkDisplay*>(gobj())), Glib::OWNERSHIP_NONE);
+  return Glib::ListHandle< Glib::RefPtr<const Device> >(gdk_display_list_devices(const_cast<GdkDisplay*>(gobj())), Glib::OWNERSHIP_DEEP);
 }
 
 GdkEvent* Display::get_event()
@@ -401,7 +390,7 @@ GdkEvent* Display::get_event()
 
 const GdkEvent* Display::get_event() const
 {
-  return const_cast<Display*>(this)->get_event();
+  return (const GdkEvent*)(gdk_display_get_event(const_cast<GdkDisplay*>(gobj())));
 }
 
 GdkEvent* Display::peek_event()
@@ -411,27 +400,27 @@ GdkEvent* Display::peek_event()
 
 GdkEvent* Display::peek_event() const
 {
-  return const_cast<Display*>(this)->peek_event();
+  return gdk_display_peek_event(const_cast<GdkDisplay*>(gobj()));
 }
 
 void Display::put_event(GdkEvent* event)
 {
-gdk_display_put_event(gobj(), event); 
+  gdk_display_put_event(gobj(), event);
 }
 
 void Display::add_client_message_filter(Glib::ustring& message_type, GdkFilterFunc func, gpointer data)
 {
-gdk_display_add_client_message_filter(gobj(), Gdk::AtomString::to_c_type(message_type), func, data); 
+  gdk_display_add_client_message_filter(gobj(), Gdk::AtomString::to_c_type(message_type), func, data);
 }
 
 void Display::set_double_click_time(guint msec)
 {
-gdk_display_set_double_click_time(gobj(), msec); 
+  gdk_display_set_double_click_time(gobj(), msec);
 }
 
 void Display::set_double_click_distance(guint distance)
 {
-gdk_display_set_double_click_distance(gobj(), distance); 
+  gdk_display_set_double_click_distance(gobj(), distance);
 }
 
 Glib::RefPtr<Display> Display::get_default()
@@ -444,45 +433,44 @@ Glib::RefPtr<Display> Display::get_default()
   return retvalue;
 }
 
-
 Glib::RefPtr<Device> Display::get_core_pointer()
 {
 
   Glib::RefPtr<Device> retvalue = Glib::wrap(gdk_display_get_core_pointer(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Device> Display::get_core_pointer() const
 {
 
   Glib::RefPtr<const Device> retvalue = Glib::wrap(gdk_display_get_core_pointer(const_cast<GdkDisplay*>(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Window> Display::get_window_at_pointer(int& win_x, int& win_y)
 {
 
   Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_window_at_pointer(gobj(), &win_x, &win_y)));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Window> Display::get_window_at_pointer(int& win_x, int& win_y) const
 {
-  return const_cast<Display*>(this)->get_window_at_pointer(win_x, win_y);
-}
 
-void Display::warp_pointer(const Glib::RefPtr<Screen>& screen, int x, int y)
-{
-gdk_display_warp_pointer(gobj(), Glib::unwrap(screen), x, y); 
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_window_at_pointer(const_cast<GdkDisplay*>(gobj()), &win_x, &win_y)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 GdkDisplayPointerHooks* Display::set_pointer_hooks(const GdkDisplayPointerHooks* new_hooks)
@@ -500,7 +488,6 @@ Glib::RefPtr<Display> Display::open_default_libgtk_only()
   return retvalue;
 }
 
-
 guint32 Display::get_drag_protocol(guint32 xid, GdkDragProtocol& protocol)
 {
   return gdk_drag_get_protocol_for_display(gobj(), xid, &(protocol));
@@ -513,7 +500,7 @@ GdkKeymap* Display::get_keymap()
 
 const GdkKeymap* Display::get_keymap() const
 {
-  return const_cast<Display*>(this)->get_keymap();
+  return gdk_keymap_get_for_display(const_cast<GdkDisplay*>(gobj()));
 }
 
 Glib::RefPtr<Pixmap> Display::lookup_pixmap(NativeWindow anid)
@@ -523,12 +510,12 @@ Glib::RefPtr<Pixmap> Display::lookup_pixmap(NativeWindow anid)
 
 Glib::RefPtr<const Pixmap> Display::lookup_pixmap(NativeWindow anid) const
 {
-  return const_cast<Display*>(this)->lookup_pixmap(anid);
+  return Glib::wrap((GdkPixmapObject*)(gdk_pixmap_lookup_for_display(const_cast<GdkDisplay*>(gobj()), (GdkNativeWindow)(anid))));
 }
 
 void Display::flush()
 {
-gdk_display_flush(gobj()); 
+  gdk_display_flush(gobj());
 }
 
 bool Display::supports_cursor_alpha() const
@@ -548,22 +535,27 @@ guint Display::get_default_cursor_size() const
 
 void Display::get_maximal_cursor_size(guint& width, guint& height)
 {
-gdk_display_get_maximal_cursor_size(gobj(), &(width), &(height)); 
+  gdk_display_get_maximal_cursor_size(gobj(), &(width), &(height));
 }
 
 Glib::RefPtr<Window> Display::get_default_group()
 {
 
   Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_default_group(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Window> Display::get_default_group() const
 {
-  return const_cast<Display*>(this)->get_default_group();
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_display_get_default_group(const_cast<GdkDisplay*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 bool Display::supports_selection_notification() const
@@ -588,7 +580,6 @@ Glib::SignalProxy1< void,bool > Display::signal_closed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gdk::Display::on_closed(bool is_error)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -598,10 +589,6 @@ void Gdk::Display::on_closed(bool is_error)
   if(base && base->closed)
     (*base->closed)(gobj(),static_cast<int>(is_error));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/display.h b/libs/gtkmm2/gdk/gdkmm/display.h
index e99910af21..238025599a 100644
--- a/libs/gtkmm2/gdk/gdkmm/display.h
+++ b/libs/gtkmm2/gdk/gdkmm/display.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_DISPLAY_H
 #define _GDKMM_DISPLAY_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -107,7 +106,7 @@ public:
   
   /** Opens a display.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param display_name The name of the display to open.
    * @return A Gdk::Display, or <tt>0</tt> if the display
    * could not be opened.
@@ -119,7 +118,7 @@ public:
    * @return A string representing the display name. This string is owned
    * by GDK and should not be modified or freed.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::ustring get_name() const;
 
@@ -127,7 +126,7 @@ public:
   /** Gets the number of screen managed by the @a display .
    * @return Number of screens.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_n_screens() const;
   
@@ -135,7 +134,7 @@ public:
    * @param screen_num The screen number.
    * @return The Gdk::Screen object
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Screen> get_screen(int screen_num);
   
@@ -143,7 +142,7 @@ public:
    * @param screen_num The screen number.
    * @return The Gdk::Screen object
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Screen> get_screen(int screen_num) const;
   
@@ -151,28 +150,28 @@ public:
   /** Get the default Gdk::Screen for @a display .
    * @return The default Gdk::Screen object for @a display 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Screen> get_default_screen();
   
   /** Get the default Gdk::Screen for @a display .
    * @return The default Gdk::Screen object for @a display 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Screen> get_default_screen() const;
   
   
   /** Release any pointer grab.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param timestamp A timestap (e.g. GDK_CURRENT_TIME).
    */
   void pointer_ungrab(guint32 timestamp);
   
   /** Release any keyboard grab
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param timestamp A timestap (e.g Gdk::CURRENT_TIME).
    */
   void keyboard_ungrab(guint32 timestamp);
@@ -180,13 +179,13 @@ public:
   /** Test if the pointer is grabbed.
    * @return <tt>true</tt> if an active X pointer grab is in effect
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool pointer_is_grabbed() const;
   
   /** Emits a short beep on @a display 
    * 
-   * @newin2p2
+   * Since: 2.2
    */
   void beep();
   
@@ -200,14 +199,14 @@ public:
    * This is most useful for X11. On windowing systems where requests are
    * handled synchronously, this function will do nothing.
    * 
-   * @newin2p2
+   * Since: 2.2
    */
   void sync();
   
   /** Closes the connection to the windowing system for the given display,
    * and cleans up associated resources.
    * 
-   * @newin2p2
+   * Since: 2.2
    */
   void	close();
 
@@ -216,7 +215,7 @@ public:
    * The list is statically allocated and should not be freed.
    * @return A list of Gdk::Device
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::ListHandle< Glib::RefPtr<Device> > list_devices();
   
@@ -224,7 +223,7 @@ public:
    * The list is statically allocated and should not be freed.
    * @return A list of Gdk::Device
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::ListHandle< Glib::RefPtr<const Device> > list_devices() const;
   
@@ -236,7 +235,7 @@ public:
    * @return The next Gdk::Event to be processed, or <tt>0</tt> if no events
    * are pending. The returned Gdk::Event should be freed with gdk_event_free().
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   GdkEvent* get_event();
   
@@ -245,7 +244,7 @@ public:
    * @return The next Gdk::Event to be processed, or <tt>0</tt> if no events
    * are pending. The returned Gdk::Event should be freed with gdk_event_free().
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   const GdkEvent* get_event() const;
   
@@ -258,7 +257,7 @@ public:
    * if no events are in the queue. The returned Gdk::Event should be freed with
    * gdk_event_free().
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   GdkEvent* peek_event();
   
@@ -270,14 +269,14 @@ public:
    * if no events are in the queue. The returned Gdk::Event should be freed with
    * gdk_event_free().
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   GdkEvent* peek_event() const;
   
   /** Appends a copy of the given event onto the front of the event
    * queue for @a display .
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param event A Gdk::Event.
    */
   void put_event(GdkEvent* event);
@@ -287,7 +286,7 @@ public:
   
   /** Adds a filter to be called when X ClientMessage events are received.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param message_type The type of ClientMessage events to receive.
    * This will be checked against the @a message_type  field 
    * of the XClientMessage event struct.
@@ -302,7 +301,7 @@ public:
    * Applications should <em>not</em> set this, it is a global 
    * user-configured setting.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param msec Double click time in milliseconds (thousandths of a second).
    */
   void set_double_click_time(guint msec);
@@ -313,7 +312,7 @@ public:
    * Applications should <em>not</em> set this, it is a global 
    * user-configured setting.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param distance Distance in pixels.
    */
   void set_double_click_distance(guint distance);
@@ -327,7 +326,7 @@ public:
    * @return A Gdk::Display, or <tt>0</tt> if there is no default
    * display.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   static Glib::RefPtr<Display> get_default();
 
@@ -336,7 +335,7 @@ public:
    * @return The core pointer device; this is owned by the
    * display and should not be freed.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Device> get_core_pointer();
   
@@ -344,7 +343,7 @@ public:
    * @return The core pointer device; this is owned by the
    * display and should not be freed.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Device> get_core_pointer() const;
 
@@ -380,7 +379,7 @@ public:
    * @param win_y Return location for origin of the window under the pointer.
    * @return The window under the mouse pointer, or <tt>0</tt>
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Window> get_window_at_pointer(int& win_x, int& win_y);
   
@@ -392,7 +391,7 @@ public:
    * @param win_y Return location for origin of the window under the pointer.
    * @return The window under the mouse pointer, or <tt>0</tt>
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Window> get_window_at_pointer(int& win_x, int& win_y) const;
 
@@ -409,26 +408,6 @@ public:
    * @result The window underneath the mouse pointer.
    */
   Glib::RefPtr<const Window> get_window_at_pointer() const;
-  
-  
-  /** Warps the pointer of @a display  to the point @a x , @a y  on 
-   * the screen @a screen , unless the pointer is confined
-   * to a window by a grab, in which case it will be moved
-   * as far as allowed by the grab. Warping the pointer 
-   * creates events as if the user had moved the mouse 
-   * instantaneously to the destination.
-   * 
-   * Note that the pointer should normally be under the
-   * control of the user. This function was added to cover
-   * some rare use cases like keyboard navigation support
-   * for the color picker in the Gtk::ColorSelectionDialog.
-   * 
-   * @newin2p8
-   * @param screen The screen of @a display  to warp the pointer to.
-   * @param x The x coordinate of the destination.
-   * @param y The y coordinate of the destination.
-   */
-  void warp_pointer(const Glib::RefPtr<Screen>& screen, int x, int y);
 
   
   /** This function allows for hooking into the operation
@@ -436,11 +415,11 @@ public:
    * display. This is only useful for such low-level tools as an
    * event recorder. Applications should never have any
    * reason to use this facility.
-   * 
-   *  @a newin2p2 
    * @param new_hooks A table of pointers to functions for getting
    * quantities related to the current pointer position.
-   * @return The previous pointer hook table.
+   * @return The previous pointer hook table
+   * 
+   * Since: 2.2.
    */
   GdkDisplayPointerHooks* set_pointer_hooks(const GdkDisplayPointerHooks* new_hooks);
   GdkDisplayPointerHooks* unset_pointer_hooks();
@@ -459,7 +438,7 @@ public:
   
   /** Finds out the DND protocol supported by a window.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param xid The X id of the destination window.
    * @param protocol Location where the supported DND protocol is returned.
    * @return The X id of the window where the drop should happen. This 
@@ -473,7 +452,7 @@ public:
    * @return The Gdk::Keymap attached to @a display .
    * the Gdk::Keymap attached to @a display .
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   GdkKeymap* get_keymap();
   
@@ -481,7 +460,7 @@ public:
    * @return The Gdk::Keymap attached to @a display .
    * the Gdk::Keymap attached to @a display .
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   const GdkKeymap* get_keymap() const;
 
@@ -498,7 +477,7 @@ public:
    * @return The Gdk::Pixmap wrapper for the native pixmap,
    * or <tt>0</tt> if there is none.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Pixmap> lookup_pixmap(NativeWindow anid);
   
@@ -510,7 +489,7 @@ public:
    * @return The Gdk::Pixmap wrapper for the native pixmap,
    * or <tt>0</tt> if there is none.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Pixmap> lookup_pixmap(NativeWindow anid) const;
 
@@ -525,7 +504,7 @@ public:
    * This is most useful for X11. On windowing systems where requests are
    * handled synchronously, this function will do nothing.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void flush();
   
@@ -534,7 +513,7 @@ public:
    * alpha (i.e. a mask).
    * @return Whether cursors can have alpha channels.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool supports_cursor_alpha() const;
   
@@ -543,20 +522,20 @@ public:
    * and a background color.
    * @return Whether cursors can have multiple colors.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool supports_cursor_color() const;
   
   /** Returns the default size to use for cursors on @a display .
    * @return The default cursor size.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   guint get_default_cursor_size() const;
   
   /** Gets the maximal size to use for cursors on @a display .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param width The return location for the maximal cursor width.
    * @param height The return location for the maximal cursor height.
    */
@@ -568,7 +547,7 @@ public:
    * See gdk_window_set_group().
    * @return The default group leader window for @a display 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<Window> get_default_group(); 
   
@@ -577,7 +556,7 @@ public:
    * See gdk_window_set_group().
    * @return The default group leader window for @a display 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const Window> get_default_group() const;              
       
@@ -589,7 +568,7 @@ public:
    * @return Whether Gdk::EventOwnerChange events will 
    * be sent.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool supports_selection_notification() const;
   
@@ -600,7 +579,7 @@ public:
    * @return Whether Gdk::EventOwnerChange events will 
    * be sent.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool request_selection_notification(const Glib::ustring& selection);
 
@@ -611,7 +590,7 @@ public:
    * running.
    * @return <tt>true</tt> if the display supports clipboard persistance.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool supports_clipboard_persistence() const;
 
@@ -621,17 +600,6 @@ public:
   void store_clipboard(const Glib::RefPtr<Gdk::Window>& clipboard_window, guint32 time_, const Glib::StringArrayHandle& targets);
                                                      
   
-  /** The closed signal is emitted when the connection to the windowing
-   * system for this display is closed.
-   *
-   * @param is_error true if the display was closed due to an error
-   */  
-  
-/**
-   * @par Prototype:
-   * <tt>void %closed(bool is_error)</tt>
-   */
-
   Glib::SignalProxy1< void,bool > signal_closed();
 
 
@@ -639,18 +607,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_closed(bool is_error);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/displaymanager.cc b/libs/gtkmm2/gdk/gdkmm/displaymanager.cc
index 3a2696788f..5edb22e506 100644
--- a/libs/gtkmm2/gdk/gdkmm/displaymanager.cc
+++ b/libs/gtkmm2/gdk/gdkmm/displaymanager.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/displaymanager.h>
 #include <gdkmm/private/displaymanager_p.h>
 
@@ -37,8 +36,7 @@ namespace Gdk
 namespace
 {
 
-
-static void DisplayManager_signal_display_opened_callback(GdkDisplayManager* self, GdkDisplay* p0,void* data)
+void DisplayManager_signal_display_opened_callback(GdkDisplayManager* self, GdkDisplay* p0,void* data)
 {
   using namespace Gdk;
   typedef sigc::slot< void,const Glib::RefPtr<Display>& > SlotType;
@@ -46,31 +44,26 @@ static void DisplayManager_signal_display_opened_callback(GdkDisplayManager* sel
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo DisplayManager_signal_display_opened_info =
+const Glib::SignalProxyInfo DisplayManager_signal_display_opened_info =
 {
   "display-opened",
   (GCallback) &DisplayManager_signal_display_opened_callback,
   (GCallback) &DisplayManager_signal_display_opened_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -117,18 +110,10 @@ void DisplayManager_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->display_opened = &display_opened_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void DisplayManager_Class::display_opened_callback(GdkDisplayManager* self, GdkDisplay* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -141,20 +126,16 @@ void DisplayManager_Class::display_opened_callback(GdkDisplayManager* self, GdkD
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_display_opened(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -167,7 +148,6 @@ void DisplayManager_Class::display_opened_callback(GdkDisplayManager* self, GdkD
       (*base->display_opened)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* DisplayManager_Class::wrap_new(GObject* object)
@@ -221,25 +201,29 @@ Glib::RefPtr<DisplayManager> DisplayManager::get()
   return retvalue;
 }
 
-
 Glib::RefPtr<Display> DisplayManager::get_default_display()
 {
 
   Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_display_manager_get_default_display(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Display> DisplayManager::get_default_display() const
 {
-  return const_cast<DisplayManager*>(this)->get_default_display();
+
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_display_manager_get_default_display(const_cast<GdkDisplayManager*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void DisplayManager::set_default_display(const Glib::RefPtr<Display>& display)
 {
-gdk_display_manager_set_default_display(gobj(), Glib::unwrap(display)); 
+  gdk_display_manager_set_default_display(gobj(), Glib::unwrap(display));
 }
 
 Glib::SListHandle< Glib::RefPtr<Display> > DisplayManager::list_displays()
@@ -254,22 +238,17 @@ Glib::SignalProxy1< void,const Glib::RefPtr<Display>& > DisplayManager::signal_d
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Display> > DisplayManager::property_default_display() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Display> >(this, "default-display");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Display> > DisplayManager::property_default_display() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Display> >(this, "default-display");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gdk::DisplayManager::on_display_opened(const Glib::RefPtr<Display>& display)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -279,10 +258,6 @@ void Gdk::DisplayManager::on_display_opened(const Glib::RefPtr<Display>& display
   if(base && base->display_opened)
     (*base->display_opened)(gobj(),Glib::unwrap(display));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/displaymanager.h b/libs/gtkmm2/gdk/gdkmm/displaymanager.h
index b15608b6f2..fb223270d6 100644
--- a/libs/gtkmm2/gdk/gdkmm/displaymanager.h
+++ b/libs/gtkmm2/gdk/gdkmm/displaymanager.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_DISPLAYMANAGER_H
 #define _GDKMM_DISPLAYMANAGER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -100,7 +99,7 @@ public:
    * the global Gdk::DisplayManager singleton; gdk_parse_pargs(),
    * gdk_init(), or gdk_init_check() must have been called first.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   static Glib::RefPtr<DisplayManager> get();
   
@@ -108,7 +107,7 @@ public:
    * @return A Gdk::Display, or <tt>0</tt> if there is no default
    * display.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Display> get_default_display();
   
@@ -116,37 +115,33 @@ public:
    * @return A Gdk::Display, or <tt>0</tt> if there is no default
    * display.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Display> get_default_display() const;
 
   
   /** Sets @a display  as the default display.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param display A Gdk::Display.
    */
   void set_default_display(const Glib::RefPtr<Display>& display);
 
   
   /** List all currently open displays.
-   * 
-   *  @a newin2p2 
    * @return A list of Gdk::Display objects.
+   * Since: 2.2.
    */
   Glib::SListHandle< Glib::RefPtr<Display> > list_displays();
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The default display for GDK.
+  /** The default display for 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< Glib::RefPtr<Display> > property_default_display() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The default display for GDK.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -154,21 +149,8 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Display> > property_default_display() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
   
-  /** The display_opened signal is emitted when a display is opened.
-   *
-   * @newin2p2
-   *
-   * @param display the opened display
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %display_opened(const Glib::RefPtr<Display>& display)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Display>& > signal_display_opened();
 
 
@@ -176,18 +158,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_display_opened(const Glib::RefPtr<Display>& display);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/dragcontext.cc b/libs/gtkmm2/gdk/gdkmm/dragcontext.cc
index 6b0ddf2963..3a2574fb72 100644
--- a/libs/gtkmm2/gdk/gdkmm/dragcontext.cc
+++ b/libs/gtkmm2/gdk/gdkmm/dragcontext.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/dragcontext.h>
 #include <gdkmm/private/dragcontext_p.h>
 
@@ -74,6 +73,7 @@ Glib::StringArrayHandle DragContext::get_targets() const
 
 } /* namespace Gdk */
 
+
 namespace
 {
 } // anonymous namespace
@@ -134,19 +134,8 @@ void DragContext_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* DragContext_Class::wrap_new(GObject* object)
 {
@@ -202,17 +191,17 @@ Glib::RefPtr<DragContext> DragContext::create()
 }
 void DragContext::drag_status(DragAction action, guint32 time)
 {
-gdk_drag_status(gobj(), ((GdkDragAction)(action)), time); 
+  gdk_drag_status(gobj(), ((GdkDragAction)(action)), time);
 }
 
 void DragContext::drop_reply(bool ok, guint32 time)
 {
-gdk_drop_reply(gobj(), static_cast<int>(ok), time); 
+  gdk_drop_reply(gobj(), static_cast<int>(ok), time);
 }
 
 void DragContext::drop_finish(bool success, guint32 time)
 {
-gdk_drop_finish(gobj(), static_cast<int>(success), time); 
+  gdk_drop_finish(gobj(), static_cast<int>(success), time);
 }
 
 Glib::ustring DragContext::get_selection() const
@@ -222,35 +211,30 @@ Glib::ustring DragContext::get_selection() const
 
 void DragContext::drag_finish(bool success, bool del, guint32 time)
 {
-gtk_drag_finish(gobj(), static_cast<int>(success), static_cast<int>(del), time); 
+  gtk_drag_finish(gobj(), static_cast<int>(success), static_cast<int>(del), time);
 }
 
 void DragContext::set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask, int hot_x, int hot_y)
 {
-gtk_drag_set_icon_pixmap(gobj(), Glib::unwrap(colormap), Glib::unwrap(pixmap), Glib::unwrap(mask), hot_x, hot_y); 
+  gtk_drag_set_icon_pixmap(gobj(), Glib::unwrap(colormap), Glib::unwrap(pixmap), Glib::unwrap(mask), hot_x, hot_y);
 }
 
 void DragContext::set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf, int hot_x, int hot_y)
 {
-gtk_drag_set_icon_pixbuf(gobj(), Glib::unwrap(pixbuf), hot_x, hot_y); 
+  gtk_drag_set_icon_pixbuf(gobj(), Glib::unwrap(pixbuf), hot_x, hot_y);
 }
 
 void DragContext::set_icon(const Glib::ustring& stock_id, int hot_x, int hot_y)
 {
-gtk_drag_set_icon_stock(gobj(), stock_id.c_str(), hot_x, hot_y); 
-}
-
-void DragContext::set_icon_name(const Glib::ustring& name, int hot_x, int hot_y)
-{
-gtk_drag_set_icon_name(gobj(), name.c_str(), hot_x, hot_y); 
+  gtk_drag_set_icon_stock(gobj(), stock_id.c_str(), hot_x, hot_y);
 }
 
 void DragContext::set_icon()
 {
-gtk_drag_set_icon_default(gobj()); 
+  gtk_drag_set_icon_default(gobj());
 }
 
- Glib::RefPtr<Window> DragContext::get_source_window()
+Glib::RefPtr<Window> DragContext::get_source_window()
 {
   Glib::RefPtr<Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->source_window)));
 
@@ -269,8 +253,8 @@ Glib::RefPtr<const Window> DragContext::get_source_window() const
 
   return ref_ptr;
 }
- 
- Glib::RefPtr<Window> DragContext::get_destination_window()
+
+Glib::RefPtr<Window> DragContext::get_destination_window()
 {
   Glib::RefPtr<Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->dest_window)));
 
@@ -289,43 +273,36 @@ Glib::RefPtr<const Window> DragContext::get_destination_window() const
 
   return ref_ptr;
 }
- 
- DragProtocol DragContext::get_protocol() const
+
+DragProtocol DragContext::get_protocol() const
 {
   return ((DragProtocol)(gobj()->protocol));
 }
- 
- bool DragContext::get_is_source() const
+
+bool DragContext::get_is_source() const
 {
   return gobj()->is_source;
 }
- 
- DragAction DragContext::get_actions() const
+
+DragAction DragContext::get_actions() const
 {
   return ((DragAction)(gobj()->actions));
 }
- 
- DragAction DragContext::get_suggested_action() const
+
+DragAction DragContext::get_suggested_action() const
 {
   return ((DragAction)(gobj()->suggested_action));
 }
- 
- DragAction DragContext::get_action() const
+
+DragAction DragContext::get_action() const
 {
   return ((DragAction)(gobj()->action));
 }
- 
- guint32 DragContext::get_start_time() const
+
+guint32 DragContext::get_start_time() const
 {
   return gobj()->start_time;
 }
- 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/dragcontext.h b/libs/gtkmm2/gdk/gdkmm/dragcontext.h
index b30d2f3715..57507df105 100644
--- a/libs/gtkmm2/gdk/gdkmm/dragcontext.h
+++ b/libs/gtkmm2/gdk/gdkmm/dragcontext.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_DRAGCONTEXT_H
 #define _GDKMM_DRAGCONTEXT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -270,22 +269,20 @@ public:
   
   void set_icon(const Glib::ustring& stock_id, int hot_x, int hot_y);
   
-  void set_icon_name(const Glib::ustring& name, int hot_x, int hot_y);
-  
   void set_icon();
 
   /** Get the the source window of this drag.
    * @result the source window of this drag.
    */
-   Glib::RefPtr<Window> get_source_window();
+  Glib::RefPtr<Window> get_source_window();
   Glib::RefPtr<const Window> get_source_window() const;
- 
+
   /** Get the the source window of this drag.
    * @result the source window of this drag.
    */
-   Glib::RefPtr<Window> get_destination_window();
+  Glib::RefPtr<Window> get_destination_window();
   Glib::RefPtr<const Window> get_destination_window() const;
-     
+    
   /** Get a list of targets offered by the source.
    * @result a list of targets offered by the source.
    */
@@ -294,33 +291,33 @@ public:
   /** Get the DND protocol which governs this drag.
    * @result the DND protocol which governs this drag.
    */
-   DragProtocol get_protocol() const;
-   
+  DragProtocol get_protocol() const;
+  
   /** Discover whether the context is used on the source side.
    * @result true if the context is used on the source side.
    */
-   bool get_is_source() const;
- 
+  bool get_is_source() const;
+
   /** Get a bitmask of actions proposed by the source when the suggested_action is Gdk::ACTION_ASK
    * @result a bitmask of actions proposed by the source when the suggested_action is Gdk::ACTION_ASK
    */
-   DragAction get_actions() const;
- 
+  DragAction get_actions() const;
+
   /** Get the action suggested by the source.
    * @result The action suggested by the source.
    */
-   DragAction get_suggested_action() const;
- 
+  DragAction get_suggested_action() const;
+
   /** Get the action chosen by the destination.
    * @result the action chosen byt the destination.
    */
-   DragAction get_action() const;
- 
+  DragAction get_action() const;
+
   /** Get a timestamp recording the start time of this drag.
    * @result a timestamp recording the start time of this drag.
    */
-   guint32 get_start_time() const;
- 
+  guint32 get_start_time() const;
+
   
   /** Finds the destination window and DND protocol to use at the
    * given pointer position. 
@@ -328,7 +325,7 @@ public:
    * This function is called by the drag source to obtain the 
    *  @a dest_window  and @a protocol  parameters for gdk_drag_motion().
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param drag_window A window which may be at the pointer position, but
    * should be ignored, since it is put up by the drag source as an icon.
    * @param screen The screen where the destination window is sought.
@@ -345,17 +342,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/drawable.cc b/libs/gtkmm2/gdk/gdkmm/drawable.cc
index 2a57382d36..58adc15cec 100644
--- a/libs/gtkmm2/gdk/gdkmm/drawable.cc
+++ b/libs/gtkmm2/gdk/gdkmm/drawable.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/drawable.h>
 #include <gdkmm/private/drawable_p.h>
 
@@ -124,19 +123,8 @@ void Drawable_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Drawable_Class::wrap_new(GObject* object)
 {
@@ -192,7 +180,7 @@ Glib::RefPtr<Drawable> Drawable::create()
 }
 void Drawable::get_size(int& width, int& height)
 {
-gdk_drawable_get_size(gobj(), &width, &height); 
+  gdk_drawable_get_size(gobj(), &width, &height);
 }
 
 int Drawable::get_depth() const
@@ -202,92 +190,92 @@ int Drawable::get_depth() const
 
 void Drawable::set_colormap(const Glib::RefPtr<Colormap>& colormap)
 {
-gdk_drawable_set_colormap(gobj(), Glib::unwrap(colormap)); 
+  gdk_drawable_set_colormap(gobj(), Glib::unwrap(colormap));
 }
 
 Glib::RefPtr<Colormap> Drawable::get_colormap()
 {
 
   Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_drawable_get_colormap(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Visual> Drawable::get_visual()
 {
 
   Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_drawable_get_visual(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 void Drawable::draw_point(const Glib::RefPtr<const GC>& gc, int x, int y)
 {
-gdk_draw_point(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y); 
+  gdk_draw_point(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y);
 }
 
 void Drawable::draw_line(const Glib::RefPtr<const GC>& gc, int x1, int y1, int x2, int y2)
 {
-gdk_draw_line(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x1, y1, x2, y2); 
+  gdk_draw_line(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x1, y1, x2, y2);
 }
 
 void Drawable::draw_rectangle(const Glib::RefPtr<const GC>& gc, bool filled, int x, int y, int width, int height)
 {
-gdk_draw_rectangle(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), static_cast<int>(filled), x, y, width, height); 
+  gdk_draw_rectangle(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), static_cast<int>(filled), x, y, width, height);
 }
 
 void Drawable::draw_arc(const Glib::RefPtr<const GC>& gc, bool filled, int x, int y, int width, int height, int angle1, int angle2)
 {
-gdk_draw_arc(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), static_cast<int>(filled), x, y, width, height, angle1, angle2); 
+  gdk_draw_arc(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), static_cast<int>(filled), x, y, width, height, angle1, angle2);
 }
 
 void Drawable::draw_drawable(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Drawable>& src, int xsrc, int ysrc, int xdest, int ydest, int width, int height)
 {
-gdk_draw_drawable(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(src)), xsrc, ysrc, xdest, ydest, width, height); 
+  gdk_draw_drawable(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<GdkDrawable*>(Glib::unwrap<Drawable>(src)), xsrc, ysrc, xdest, ydest, width, height);
 }
 
 void Drawable::draw_image(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Image>& image, int xsrc, int ysrc, int xdest, int ydest, int width, int height)
 {
-gdk_draw_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<GdkImage*>(Glib::unwrap<Image>(image)), xsrc, ysrc, xdest, ydest, width, height); 
+  gdk_draw_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<GdkImage*>(Glib::unwrap<Image>(image)), xsrc, ysrc, xdest, ydest, width, height);
 }
 
 void Drawable::draw_segments(const Glib::RefPtr<const GC>& gc, GdkSegment* segs, int nsegs)
 {
-gdk_draw_segments(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), segs, nsegs); 
+  gdk_draw_segments(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), segs, nsegs);
 }
 
 void Drawable::draw_glyphs(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<const Pango::Font>& font, int x, int y, const Pango::GlyphString& glyphs)
 {
-gdk_draw_glyphs(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<PangoFont*>(Glib::unwrap<Pango::Font>(font)), x, y, const_cast<PangoGlyphString*>(glyphs.gobj())); 
+  gdk_draw_glyphs(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), const_cast<PangoFont*>(Glib::unwrap<Pango::Font>(font)), x, y, const_cast<PangoGlyphString*>(glyphs.gobj()));
 }
 
 void Drawable::draw_layout_line(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::LayoutLine>& line)
 {
-gdk_draw_layout_line(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayoutLine*>(Glib::unwrap<Pango::LayoutLine>(line))); 
+  gdk_draw_layout_line(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayoutLine*>(Glib::unwrap<Pango::LayoutLine>(line)));
 }
 
 void Drawable::draw_layout_line(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::LayoutLine>& line, const Color& foreground, const Color& background)
 {
-gdk_draw_layout_line_with_colors(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayoutLine*>(Glib::unwrap<Pango::LayoutLine>(line)), (foreground).gobj(), (background).gobj()); 
+  gdk_draw_layout_line_with_colors(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayoutLine*>(Glib::unwrap<Pango::LayoutLine>(line)), (foreground).gobj(), (background).gobj());
 }
 
 void Drawable::draw_layout(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::Layout>& layout)
 {
-gdk_draw_layout(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayout*>(Glib::unwrap<Pango::Layout>(layout))); 
+  gdk_draw_layout(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayout*>(Glib::unwrap<Pango::Layout>(layout)));
 }
 
 void Drawable::draw_layout(const Glib::RefPtr<const GC>& gc, int x, int y, const Glib::RefPtr<const Pango::Layout>& layout, const Color& foreground, const Color& background)
 {
-gdk_draw_layout_with_colors(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayout*>(Glib::unwrap<Pango::Layout>(layout)), (foreground).gobj(), (background).gobj()); 
+  gdk_draw_layout_with_colors(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, const_cast<PangoLayout*>(Glib::unwrap<Pango::Layout>(layout)), (foreground).gobj(), (background).gobj());
 }
 
 void Drawable::draw_pixbuf(const Glib::RefPtr<const GC>& gc, const Glib::RefPtr<Pixbuf>& pixbuf, int src_x, int src_y, int dest_x, int dest_y, int width, int height, RgbDither dither, int x_dither, int y_dither)
 {
-gdk_draw_pixbuf(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), Glib::unwrap(pixbuf), src_x, src_y, dest_x, dest_y, width, height, ((GdkRgbDither)(dither)), x_dither, y_dither); 
+  gdk_draw_pixbuf(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), Glib::unwrap(pixbuf), src_x, src_y, dest_x, dest_y, width, height, ((GdkRgbDither)(dither)), x_dither, y_dither);
 }
 
 Glib::RefPtr<Image> Drawable::get_image(int x, int y, int width, int height) const
@@ -307,75 +295,73 @@ Region Drawable::get_visible_region() const
 
 void Drawable::draw_rgb_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride)
 {
-gdk_draw_rgb_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride); 
+  gdk_draw_rgb_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride);
 }
 
 void Drawable::draw_rgb_image_dithalign(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride, int xdith, int ydith)
 {
-gdk_draw_rgb_image_dithalign(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride, xdith, ydith); 
+  gdk_draw_rgb_image_dithalign(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride, xdith, ydith);
 }
 
 void Drawable::draw_rgb_32_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride)
 {
-gdk_draw_rgb_32_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride); 
+  gdk_draw_rgb_32_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride);
 }
 
 void Drawable::draw_rgb_32_image_dithalign(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* buf, int rowstride, int xdith, int ydith)
 {
-gdk_draw_rgb_32_image_dithalign(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(buf), rowstride, xdith, ydith); 
+  gdk_draw_rgb_32_image_dithalign(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(buf), rowstride, xdith, ydith);
 }
 
 void Drawable::draw_gray_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride)
 {
-gdk_draw_gray_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride); 
+  gdk_draw_gray_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride);
 }
 
 void Drawable::draw_indexed_image(const Glib::RefPtr<const GC>& gc, int x, int y, int width, int height, RgbDither dith, const guchar* rgb_buf, int rowstride, const RgbCmap& cmap)
 {
-gdk_draw_indexed_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride, const_cast<GdkRgbCmap*>(cmap.gobj())); 
+  gdk_draw_indexed_image(gobj(), const_cast<GdkGC*>(Glib::unwrap<GC>(gc)), x, y, width, height, ((GdkRgbDither)(dith)), const_cast<guchar*>(rgb_buf), rowstride, const_cast<GdkRgbCmap*>(cmap.gobj()));
 }
 
 Glib::RefPtr<Screen> Drawable::get_screen()
 {
 
   Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_drawable_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Screen> Drawable::get_screen() const
 {
-  return const_cast<Drawable*>(this)->get_screen();
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_drawable_get_screen(const_cast<GdkDrawable*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Display> Drawable::get_display()
 {
 
   Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_drawable_get_display(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Display> Drawable::get_display() const
 {
-  return const_cast<Drawable*>(this)->get_display();
-}
 
-Cairo::RefPtr<Cairo::Context> Drawable::create_cairo_context()
-{
-  return Cairo::RefPtr<Cairo::Context>(new Cairo::Context(gdk_cairo_create(gobj()), true /* has_reference */));
-}
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_drawable_get_display(const_cast<GdkDrawable*>(gobj())));
 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/drawable.h b/libs/gtkmm2/gdk/gdkmm/drawable.h
index ccf3310e57..6331e46ff2 100644
--- a/libs/gtkmm2/gdk/gdkmm/drawable.h
+++ b/libs/gtkmm2/gdk/gdkmm/drawable.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_DRAWABLE_H
 #define _GDKMM_DRAWABLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -37,7 +36,6 @@
 #include <gdkmm/region.h>
 #include <gdkmm/rgbcmap.h>
 #include <gdkmm/types.h>
-#include <cairomm/context.h>
 //#include <gdkmm/pixbuf.h>
 
 
@@ -97,12 +95,7 @@ class Pixbuf;
  *
  * To use a drawable, create a concrete Drawable of the type you wish to use
  * and a Gdk::GC (graphics context) for that Drawable.  With the GC you can
- * draw lines, text, arcs and such. 
- *
- * An alternative is to create a Cairo::Context with get_cairo_context()
- * while you handle the 'exposed' event of the drawable. For more about
- * this, please see "Using cairo with GTK+" in the "Common questions" section
- * of the GTK+ Reference Manual.
+ * draw lines, text, arcs and such.
  */
 
 class Drawable : public Glib::Object
@@ -272,9 +265,9 @@ public:
    * colormap, or errors will result. (On X11, failure to match
    * visual/colormap results in a BadMatch error from the X server.)
    * A common cause of this problem is an attempt to draw a bitmap to
-   * a color drawable. The way to draw a bitmap is to set the bitmap as 
-   * the stipple on the Gdk::GC, set the fill mode to Gdk::STIPPLED, and 
-   * then draw the rectangle.
+   * a color drawable. The way to draw a bitmap is to set the
+   * bitmap as a clip mask on your Gdk::GC, then use gdk_draw_rectangle()
+   * to draw a rectangle clipped to the bitmap.
    * @param gc A Gdk::GC sharing the drawable's visual and colormap.
    * @param src The source Gdk::Drawable, which may be the same as @a drawable .
    * @param xsrc X position in @a src  of rectangle to draw.
@@ -409,7 +402,7 @@ public:
    * The clip mask of @a gc  is ignored, but clip rectangles and clip regions work
    * fine.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param gc A Gdk::GC, used for clipping, or <tt>0</tt>.
    * @param pixbuf A Gdk::Pixbuf.
    * @param src_x Source X coordinate within pixbuf.
@@ -435,8 +428,8 @@ public:
    * server-side drawable as a client-side Gdk::Image.  The format of a
    * Gdk::Image depends on the Gdk::Visual of the current display, which
    * makes manipulating Gdk::Image extremely difficult; therefore, in
-   * most cases you should use the Gdk::Pixbuf::create() method that takes a Gdk::Drawable, 
-   * instead of this lower-level function. A Gdk::Pixbuf contains image data in a
+   * most cases you should use Gdk::Pixbuf::get_from_drawable() instead of
+   * this lower-level function. A Gdk::Pixbuf contains image data in a
    * canonicalized RGB format, rather than a display-dependent format.
    * Of course, there's a convenience vs. speed tradeoff here, so you'll
    * want to think about what makes sense for your application.
@@ -550,14 +543,14 @@ public:
   /** Gets the Gdk::Screen associated with a Gdk::Drawable.
    * @return The Gdk::Screen associated with @a drawable 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Screen> get_screen();
   
   /** Gets the Gdk::Screen associated with a Gdk::Drawable.
    * @return The Gdk::Screen associated with @a drawable 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Screen> get_screen() const;
 
@@ -565,41 +558,27 @@ public:
   /** Gets the Gdk::Display associated with a Gdk::Drawable.
    * @return The Gdk::Display associated with @a drawable 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Display> get_display();
   
   /** Gets the Gdk::Display associated with a Gdk::Drawable.
    * @return The Gdk::Display associated with @a drawable 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Display> get_display() const;
 
-   
-  /** Creates a Cairo context for drawing to @a drawable .
-   * @return A newly created Cairo context.
-   * 
-   * @newin2p10.
-   */
-  Cairo::RefPtr<Cairo::Context> create_cairo_context();
-
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/event.cc b/libs/gtkmm2/gdk/gdkmm/event.cc
index 14a1b4f272..e9a71e918c 100644
--- a/libs/gtkmm2/gdk/gdkmm/event.cc
+++ b/libs/gtkmm2/gdk/gdkmm/event.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/event.h>
 #include <gdkmm/private/event_p.h>
 
@@ -133,22 +132,19 @@ Event Event::get()
   return Event(gdk_event_get());
 }
 
-
 Event Event::peek()
 {
   return Event(gdk_event_peek());
 }
 
-
 Event Event::get_graphics_expose(const Glib::RefPtr<Window>& window)
 {
   return Event(gdk_event_get_graphics_expose(Glib::unwrap(window)));
 }
 
-
 void Event::put()
 {
-gdk_event_put(gobj()); 
+  gdk_event_put(gobj());
 }
 
 bool Event::events_pending()
@@ -156,7 +152,6 @@ bool Event::events_pending()
   return gdk_events_pending();
 }
 
-
 guint32 Event::get_time() const
 {
   return gdk_event_get_time(const_cast<GdkEvent*>(gobj()));
@@ -184,34 +179,37 @@ bool Event::get_axis(AxisUse axis_use, double& value) const
 
 void Event::set_show_events(bool show_events)
 {
-gdk_set_show_events(static_cast<int>(show_events));
+  gdk_set_show_events(static_cast<int>(show_events));
 }
 
-
 bool Event::get_show_events()
 {
   return gdk_get_show_events();
 }
 
-
 void Event::set_screen(const Glib::RefPtr<Screen>& screen)
 {
-gdk_event_set_screen(gobj(), Glib::unwrap(screen)); 
+  gdk_event_set_screen(gobj(), Glib::unwrap(screen));
 }
 
 Glib::RefPtr<Screen> Event::get_screen()
 {
 
   Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_event_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Screen> Event::get_screen() const
 {
-  return const_cast<Event*>(this)->get_screen();
+
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_event_get_screen(const_cast<GdkEvent*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 bool Event::send_client_message(NativeWindow winid)
diff --git a/libs/gtkmm2/gdk/gdkmm/event.h b/libs/gtkmm2/gdk/gdkmm/event.h
index eecc131cf4..8d1095d46b 100644
--- a/libs/gtkmm2/gdk/gdkmm/event.h
+++ b/libs/gtkmm2/gdk/gdkmm/event.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_EVENT_H
 #define _GDKMM_EVENT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -89,8 +88,7 @@ enum EventType
   SCROLL,
   WINDOW_STATE,
   SETTING,
-  OWNER_CHANGE,
-  GRAB_BROKEN
+  OWNER_CHANGE
 };
 
 } // namespace Gdk
@@ -318,7 +316,7 @@ public:
    * have been allocated by GTK+, for instance, by
    * gdk_event_copy().
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param screen A Gdk::Screen.
    */
   void set_screen(const Glib::RefPtr<Screen>& screen);
@@ -326,26 +324,26 @@ public:
   /** Returns the screen for the event. The screen is
    * typically the screen for <tt>event->any.window</tt>, but
    * for events such as mouse events, it is the screen
-   * where the pointer was when the event occurs -
+   * where the the pointer was when the event occurs -
    * that is, the screen which has the root window 
    * to which <tt>event->motion.x_root</tt> and
    * <tt>event->motion.y_root</tt> are relative.
    * @return The screen for the event
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Screen> get_screen();
   
   /** Returns the screen for the event. The screen is
    * typically the screen for <tt>event->any.window</tt>, but
    * for events such as mouse events, it is the screen
-   * where the pointer was when the event occurs -
+   * where the the pointer was when the event occurs -
    * that is, the screen which has the root window 
    * to which <tt>event->motion.x_root</tt> and
    * <tt>event->motion.y_root</tt> are relative.
    * @return The screen for the event
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Screen> get_screen() const;
 
@@ -396,6 +394,5 @@ class Value<Gdk::Event> : public Glib::Value_Boxed<Gdk::Event>
 
 } // namespace Glib
 
-
 #endif /* _GDKMM_EVENT_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/gc.cc b/libs/gtkmm2/gdk/gdkmm/gc.cc
index eeddc82148..456cad5f9e 100644
--- a/libs/gtkmm2/gdk/gdkmm/gc.cc
+++ b/libs/gtkmm2/gdk/gdkmm/gc.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/gc.h>
 #include <gdkmm/private/gc_p.h>
 
@@ -137,19 +136,8 @@ void GC_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* GC_Class::wrap_new(GObject* object)
 {
@@ -209,135 +197,128 @@ Glib::RefPtr<GC> GC::create(const Glib::RefPtr<Drawable>& drawable)
 }
 void GC::set_foreground(const Color& color)
 {
-gdk_gc_set_foreground(gobj(), (color).gobj()); 
+  gdk_gc_set_foreground(gobj(), (color).gobj());
 }
 
 void GC::set_background(const Color& color)
 {
-gdk_gc_set_background(gobj(), (color).gobj()); 
+  gdk_gc_set_background(gobj(), (color).gobj());
 }
 
 void GC::set_function(Function function)
 {
-gdk_gc_set_function(gobj(), ((GdkFunction)(function))); 
+  gdk_gc_set_function(gobj(), ((GdkFunction)(function)));
 }
 
 void GC::set_fill(Fill fill)
 {
-gdk_gc_set_fill(gobj(), ((GdkFill)(fill))); 
+  gdk_gc_set_fill(gobj(), ((GdkFill)(fill)));
 }
 
 void GC::set_tile(const Glib::RefPtr<Pixmap>& tile)
 {
-gdk_gc_set_tile(gobj(), Glib::unwrap(tile)); 
+  gdk_gc_set_tile(gobj(), Glib::unwrap(tile));
 }
 
 void GC::set_stipple(const Glib::RefPtr<Pixmap>& stipple)
 {
-gdk_gc_set_stipple(gobj(), Glib::unwrap(stipple)); 
+  gdk_gc_set_stipple(gobj(), Glib::unwrap(stipple));
 }
 
 void GC::set_ts_origin(int x, int y)
 {
-gdk_gc_set_ts_origin(gobj(), x, y); 
+  gdk_gc_set_ts_origin(gobj(), x, y);
 }
 
 void GC::set_clip_origin(int x, int y)
 {
-gdk_gc_set_clip_origin(gobj(), x, y); 
+  gdk_gc_set_clip_origin(gobj(), x, y);
 }
 
 void GC::set_clip_mask(const Glib::RefPtr<Bitmap>& mask)
 {
-gdk_gc_set_clip_mask(gobj(), Glib::unwrap(mask)); 
+  gdk_gc_set_clip_mask(gobj(), Glib::unwrap(mask));
 }
 
 void GC::set_clip_rectangle(Rectangle& rectangle)
 {
-gdk_gc_set_clip_rectangle(gobj(), (rectangle).gobj()); 
-}
-
-void GC::set_clip_rectangle(const Rectangle& rectangle)
-{
-gdk_gc_set_clip_rectangle(gobj(), const_cast<GdkRectangle*>(rectangle.gobj())); 
+  gdk_gc_set_clip_rectangle(gobj(), (rectangle).gobj());
 }
 
 void GC::set_clip_region(const Region& region)
 {
-gdk_gc_set_clip_region(gobj(), const_cast<GdkRegion*>((region).gobj())); 
+  gdk_gc_set_clip_region(gobj(), const_cast<GdkRegion*>((region).gobj()));
 }
 
 void GC::set_subwindow(SubwindowMode mode)
 {
-gdk_gc_set_subwindow(gobj(), ((GdkSubwindowMode)(mode))); 
+  gdk_gc_set_subwindow(gobj(), ((GdkSubwindowMode)(mode)));
 }
 
 void GC::set_exposures(bool exposures)
 {
-gdk_gc_set_exposures(gobj(), static_cast<int>(exposures)); 
+  gdk_gc_set_exposures(gobj(), static_cast<int>(exposures));
 }
 
 void GC::set_line_attributes(int line_width, LineStyle line_style, CapStyle cap_style, JoinStyle join_style)
 {
-gdk_gc_set_line_attributes(gobj(), line_width, ((GdkLineStyle)(line_style)), ((GdkCapStyle)(cap_style)), ((GdkJoinStyle)(join_style))); 
+  gdk_gc_set_line_attributes(gobj(), line_width, ((GdkLineStyle)(line_style)), ((GdkCapStyle)(cap_style)), ((GdkJoinStyle)(join_style)));
 }
 
 void GC::set_dashes(int dash_offset, gint8* dash_list, int n)
 {
-gdk_gc_set_dashes(gobj(), dash_offset, dash_list, n); 
+  gdk_gc_set_dashes(gobj(), dash_offset, dash_list, n);
 }
 
 void GC::offset(int x_offset, int y_offset)
 {
-gdk_gc_offset(gobj(), x_offset, y_offset); 
+  gdk_gc_offset(gobj(), x_offset, y_offset);
 }
 
 void GC::set_colormap(const Glib::RefPtr<Colormap>& colormap)
 {
-gdk_gc_set_colormap(gobj(), Glib::unwrap(colormap)); 
+  gdk_gc_set_colormap(gobj(), Glib::unwrap(colormap));
 }
 
 Glib::RefPtr<Colormap> GC::get_colormap()
 {
 
   Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_gc_get_colormap(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 void GC::set_rgb_fg_color(const Color& color)
 {
-gdk_gc_set_rgb_fg_color(gobj(), (color).gobj()); 
+  gdk_gc_set_rgb_fg_color(gobj(), (color).gobj());
 }
 
 void GC::set_rgb_bg_color(const Color& color)
 {
-gdk_gc_set_rgb_bg_color(gobj(), (color).gobj()); 
+  gdk_gc_set_rgb_bg_color(gobj(), (color).gobj());
 }
 
 Glib::RefPtr<Screen> GC::get_screen()
 {
 
   Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_gc_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Screen> GC::get_screen() const
 {
-  return const_cast<GC*>(this)->get_screen();
-}
-
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_gc_get_screen(const_cast<GdkGC*>(gobj())));
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/gc.h b/libs/gtkmm2/gdk/gdkmm/gc.h
index 5c156d706e..854995eee5 100644
--- a/libs/gtkmm2/gdk/gdkmm/gc.h
+++ b/libs/gtkmm2/gdk/gdkmm/gc.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_GC_H
 #define _GDKMM_GC_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -470,9 +469,6 @@ public:
    * @param mask A bitmap.
    */
   void set_clip_mask(const Glib::RefPtr<Bitmap>& mask);
-
-  /** @deprecated Use set_clip_rectangle(const Rectangle& rectangle) instead.
-   */
   
   /** Sets the clip mask for a graphics context from a
    * rectangle. The clip mask is interpreted relative to the clip
@@ -481,14 +477,6 @@ public:
    */
   void set_clip_rectangle(Rectangle& rectangle);
   
-  /** Sets the clip mask for a graphics context from a
-   * rectangle. The clip mask is interpreted relative to the clip
-   * origin. (See set_clip_origin()).
-   * @param rectangle The rectangle to clip to.
-   */
-  void set_clip_rectangle(const Rectangle& rectangle);
-
-  
   /** Sets the clip mask for a graphics context from a region structure.
    * The clip mask is interpreted relative to the clip origin. (See
    * set_clip_origin()).
@@ -586,14 +574,14 @@ public:
   /** Gets the Gdk::Screen for which @a gc  was created
    * @return The Gdk::Screen for @a gc .
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Screen> get_screen();
   
   /** Gets the Gdk::Screen for which @a gc  was created
    * @return The Gdk::Screen for @a gc .
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Screen> get_screen() const;
 
@@ -602,17 +590,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/general.cc b/libs/gtkmm2/gdk/gdkmm/general.cc
index 48729f95a8..f07cce2b14 100644
--- a/libs/gtkmm2/gdk/gdkmm/general.cc
+++ b/libs/gtkmm2/gdk/gdkmm/general.cc
@@ -50,35 +50,5 @@ void flush()
   gdk_flush();
 }
 
-namespace Cairo
-{
-
-void set_source_color(::Cairo::RefPtr< ::Cairo::Context >& context, const Gdk::Color& color)
-{
-  gdk_cairo_set_source_color(context->cobj(), const_cast<GdkColor*>(color.gobj()));
-}
-
-void set_source_pixbuf(::Cairo::RefPtr< ::Cairo::Context >& context, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf, double pixbuf_x, double pixbuf_y)
-{
-  gdk_cairo_set_source_pixbuf(context->cobj(), pixbuf->gobj(), pixbuf_x, pixbuf_y);
-}
-
-void set_source_pixmap(::Cairo::RefPtr< ::Cairo::Context >& context, const Glib::RefPtr<Gdk::Pixmap>& pixmap, double pixmap_x, double pixmap_y)
-{
-  gdk_cairo_set_source_pixmap(context->cobj(), pixmap->gobj(), pixmap_x, pixmap_y);
-}
-
-void rectangle(::Cairo::RefPtr< ::Cairo::Context >& context, const Gdk::Rectangle& rectangle)
-{
-  gdk_cairo_rectangle(context->cobj(), const_cast<GdkRectangle*>(rectangle.gobj()));
-}
-
-void region(::Cairo::RefPtr< ::Cairo::Context >& context, const Gdk::Region& region)
-{
-  gdk_cairo_region(context->cobj(), const_cast<GdkRegion*>(region.gobj()));
-}
-
-} //namespace Cairo
-
 } //namespace Gdk
 
diff --git a/libs/gtkmm2/gdk/gdkmm/general.h b/libs/gtkmm2/gdk/gdkmm/general.h
index b5b6164a8d..1d37ab0e3b 100644
--- a/libs/gtkmm2/gdk/gdkmm/general.h
+++ b/libs/gtkmm2/gdk/gdkmm/general.h
@@ -20,9 +20,6 @@
 #ifndef _GDKMM_GENERAL_H
 #define _GDKMM_GENERAL_H
 
-#include <gdkmm/pixbuf.h>
-#include <cairomm/context.h>
-
 namespace Gdk
 {
 
@@ -34,59 +31,6 @@ int screen_height_mm();
 
 void flush();
 
-namespace Cairo
-{
-
-/** Sets the specified Gdk::Color as the source color of the Cairo context.
- * @param @context The cairo context.
- * @param color The color to use as the source color. 
- *
- * @newin2p10
- */
-void set_source_color(::Cairo::RefPtr< ::Cairo::Context >& context, const Gdk::Color& color);
-
-/** Sets the given pixbuf as the source pattern for the Cairo context. The pattern has an extend mode of CAIRO_EXTEND_NONE and is aligned so that the origin of pixbuf is pixbuf_x, pixbuf_y.
- * @param @context The cairo context.
- * @param pixbuf A Gdk::Pixbuf
- * @param pixbuf_x X coordinate of location to place upper left corner of pixbuf.
- * @param pixbuf_y Y coordinate of location to place upper left corner of pixbuf.
- *
- * @newin2p10
- */
-void set_source_pixbuf(::Cairo::RefPtr< ::Cairo::Context >& context, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf, double pixbuf_x, double pixbuf_y);
-
-/** Sets the given pixbuf as the source pattern for the Cairo context. The pattern has an extend mode of CAIRO_EXTEND_NONE and is aligned so that the origin of pixbuf is pixmap_x, pixmap_y.
- * @param @context The cairo context.
- * @param pixmap A Gdk::Pixmap
- * @param pixmap_x X coordinate of location to place upper left corner of pixmap.
- * @param pixmap_y Y coordinate of location to place upper left corner of pixmap.
- *
- * @newin2p10
- */
-void set_source_pixmap(::Cairo::RefPtr< ::Cairo::Context >& context, const Glib::RefPtr<Gdk::Pixmap>& pixmap, double pixmap_x, double pixmap_y);
-
-//TODO: Rename to add_rectangle_to_context_path and add_region_to_context_path(), and deprecate rectangle() and region()?
-
-/** Adds the given rectangle to the current path of the context.
- *
- * @param context A cairo context.
- * @param rectangle A rectangle to add to the path of the context. 
- *
- * @newin2p10
- */
-void rectangle(::Cairo::RefPtr< ::Cairo::Context >& context, const Gdk::Rectangle& rectangle);
-
-/** Adds the given region to the current path of the context.
- *
- * @param context A cairo context.
- * @param region A region to add to the path of the context. 
- *
- * @newin2p10
- */
-void region(::Cairo::RefPtr< ::Cairo::Context >& context, const Gdk::Region& region);
-
-} //namespace Cairo
-
 } //namespace Gdk
 
 #endif //_GDKMM_GENERAL_H
diff --git a/libs/gtkmm2/gdk/gdkmm/image.cc b/libs/gtkmm2/gdk/gdkmm/image.cc
index 0899ae0723..787124f36f 100644
--- a/libs/gtkmm2/gdk/gdkmm/image.cc
+++ b/libs/gtkmm2/gdk/gdkmm/image.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/image.h>
 #include <gdkmm/private/image_p.h>
 
@@ -92,19 +91,8 @@ void Image_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Image_Class::wrap_new(GObject* object)
 {
@@ -153,7 +141,7 @@ Glib::RefPtr<Image> Image::create(ImageType type, const Glib::RefPtr<Visual>& vi
 }
 void Image::put_pixel(int x, int y, guint32 pixel)
 {
-gdk_image_put_pixel(gobj(), x, y, pixel); 
+  gdk_image_put_pixel(gobj(), x, y, pixel);
 }
 
 guint32 Image::get_pixel(int x, int y) const
@@ -163,30 +151,35 @@ guint32 Image::get_pixel(int x, int y) const
 
 void Image::set_colormap(const Glib::RefPtr<Colormap>& colormap)
 {
-gdk_image_set_colormap(gobj(), Glib::unwrap(colormap)); 
+  gdk_image_set_colormap(gobj(), Glib::unwrap(colormap));
 }
 
 Glib::RefPtr<Colormap> Image::get_colormap()
 {
 
   Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_image_get_colormap(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Colormap> Image::get_colormap() const
 {
-  return const_cast<Image*>(this)->get_colormap();
+
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_image_get_colormap(const_cast<GdkImage*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
- ImageType Image::get_image_type() const
+ImageType Image::get_image_type() const
 {
   return ((ImageType)(gobj()->type));
 }
- 
- Glib::RefPtr<Visual> Image::get_visual()
+
+Glib::RefPtr<Visual> Image::get_visual()
 {
   Glib::RefPtr<Visual> ref_ptr(Glib::wrap(gobj()->visual));
 
@@ -205,38 +198,38 @@ Glib::RefPtr<const Visual> Image::get_visual() const
 
   return ref_ptr;
 }
- 
- ByteOrder Image::get_byte_order() const
+
+ByteOrder Image::get_byte_order() const
 {
   return ((ByteOrder)(gobj()->byte_order));
 }
- 
- int Image::get_width() const
+
+int Image::get_width() const
 {
   return gobj()->width;
 }
- 
- int Image::get_height() const
+
+int Image::get_height() const
 {
   return gobj()->height;
 }
- 
- guint16 Image::get_bpp() const
+
+guint16 Image::get_bpp() const
 {
   return gobj()->bpp;
 }
- 
- guint16 Image::get_bpl() const
+
+guint16 Image::get_bpl() const
 {
   return gobj()->bpl;
 }
- 
- guint16 Image::get_bits_per_pixel() const
+
+guint16 Image::get_bits_per_pixel() const
 {
   return gobj()->bits_per_pixel;
 }
- 
- void* Image::get_mem()
+
+void* Image::get_mem()
 {
   return gobj()->mem;
 }
@@ -245,18 +238,11 @@ const void* Image::get_mem() const
 {
   return (const void*)(gobj()->mem);
 }
- 
- void* Image::get_windowing_data() const
+
+void* Image::get_windowing_data() const
 {
   return gobj()->windowing_data;
 }
- 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/image.h b/libs/gtkmm2/gdk/gdkmm/image.h
index 5b9fa7f33b..7d5f8f6078 100644
--- a/libs/gtkmm2/gdk/gdkmm/image.h
+++ b/libs/gtkmm2/gdk/gdkmm/image.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_IMAGE_H
 #define _GDKMM_IMAGE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -151,12 +150,12 @@ public:
   static Glib::RefPtr<Image> create(ImageType type, const Glib::RefPtr<Visual>& visual, int width, int height);
 
 
-  //We ignore gdk_image_new_bitmap() because the documentation says that it is deprecated.
+  //We ignore gdk_image_new_bitmap() because the documentation says that it is incredibly broken.
   
 
   void put_pixel(int x, int y, guint32 pixel);
   
-  guint32 get_pixel(int x, int y) const;
+  guint32 get_pixel(int	x, int	y) const;
   
   /** Sets the colormap for the image to the given colormap.  Normally
    * there's no need to use this function, images are created with the
@@ -183,39 +182,33 @@ public:
    */
   Glib::RefPtr<const Colormap> get_colormap() const;
   
-   ImageType get_image_type() const;
-    Glib::RefPtr<Visual> get_visual();
+  ImageType get_image_type() const;
+  Glib::RefPtr<Visual> get_visual();
   Glib::RefPtr<const Visual> get_visual() const;
-    ByteOrder get_byte_order() const;
-    int get_width() const;
-    int get_height() const;
-    guint16 get_bpp() const;
-    guint16 get_bpl() const;
-    guint16 get_bits_per_pixel() const;
- 
+  ByteOrder get_byte_order() const;
+  int get_width() const;
+  int get_height() const;
+  guint16 get_bpp() const;
+  guint16 get_bpl() const;
+  guint16 get_bits_per_pixel() const;
+
   //This memory block is not read-only, apparently:
-   void* get_mem();
+  void* get_mem();
   const void* get_mem() const;
- 
+
   //TODO: This should be const really.
-   void* get_windowing_data() const;
- 
+  void* get_windowing_data() const;
+
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbuf.cc b/libs/gtkmm2/gdk/gdkmm/pixbuf.cc
index 4a97b5dac9..8a486d3cc9 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbuf.cc
+++ b/libs/gtkmm2/gdk/gdkmm/pixbuf.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/pixbuf.h>
 #include <gdkmm/private/pixbuf_p.h>
 
@@ -33,23 +32,19 @@
 namespace
 {
 
-static void pixbuf_destroy_data_callback(guint8* pixels, void* user_data)
+void pixbuf_destroy_data_callback(guint8* pixels, void* user_data)
 {
   Gdk::Pixbuf::SlotDestroyData *const slot = static_cast<Gdk::Pixbuf::SlotDestroyData*>(user_data);
   g_return_if_fail(slot != 0);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     (*slot)(pixels); // invoke callback
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   delete slot;
 }
@@ -80,6 +75,28 @@ Pixbuf::Pixbuf(const Glib::RefPtr<Drawable>& src,
       0, src->gobj(), cmap->gobj(), src_x, src_y, dest_x, dest_y, width, height))
 {}
 
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename)
+{
+  GError* error = 0;
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_file(filename.c_str(), &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+
+  return Glib::wrap(pixbuf);
+}
+
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename, int width, int size, bool preserve_aspect_ratio)
+{
+  GError* error = 0;
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_file_at_scale(filename.c_str(), width, size, preserve_aspect_ratio, &error);
+  //gdk_pixbuf_new_from_file_at_size() just calls gdk_pixbuf_new_from_file_at_scale().
+
+  if(error)
+    Glib::Error::throw_exception(error);
+
+  return Glib::wrap(pixbuf);
+}
 
 Glib::RefPtr<Pixbuf> Pixbuf::create_from_data(const guint8* data, Colorspace colorspace,
                                               bool has_alpha, int bits_per_sample,
@@ -104,6 +121,17 @@ Glib::RefPtr<Pixbuf> Pixbuf::create_from_data(const guint8* data, Colorspace col
   return Glib::wrap(pixbuf);
 }
 
+Glib::RefPtr<Pixbuf> Pixbuf::create_from_inline(int data_length, const guint8* data, bool copy_pixels)
+{
+  GError* error = 0;
+  GdkPixbuf *const pixbuf = gdk_pixbuf_new_from_inline(data_length, data, copy_pixels, &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+
+  return Glib::wrap(pixbuf);
+}
+
 void Pixbuf::render_pixmap_and_mask_for_colormap(const Glib::RefPtr<Colormap>& colormap,
                                                  Glib::RefPtr<Pixmap>& pixmap_return,
                                                  Glib::RefPtr<Bitmap>& mask_return,
@@ -132,104 +160,45 @@ void Pixbuf::render_pixmap_and_mask(Glib::RefPtr<Pixmap>& pixmap_return,
   mask_return   = Glib::RefPtr<Gdk::Bitmap>::cast_dynamic(Glib::wrap((GdkPixmapObject*) pBitmap));
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Pixbuf::save(const std::string& filename, const Glib::ustring& type)
-#else
-void Pixbuf::save(const std::string& filename, const Glib::ustring& type, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
-  gdk_pixbuf_savev(gobj(), filename.c_str(), type.c_str(), 0, 0, &gerror);
+  GError* error = 0;
+  gdk_pixbuf_savev(gobj(), filename.c_str(), type.c_str(), 0, 0, &error);
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Glib::Error::throw_exception(error);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Pixbuf::save(const std::string& filename, const Glib::ustring& type,
                   const Glib::StringArrayHandle& option_keys,
                   const Glib::StringArrayHandle& option_values)
-#else
-void Pixbuf::save(const std::string& filename, const Glib::ustring& type,
-                  const Glib::StringArrayHandle& option_keys,
-                  const Glib::StringArrayHandle& option_values, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
+  GError* error = 0;
 
   gdk_pixbuf_savev(
       gobj(), filename.c_str(), type.c_str(),
       const_cast<char**>(option_keys.data()), const_cast<char**>(option_values.data()),
-      &gerror);
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-void Pixbuf::save_to_buffer(gchar*& buffer, gsize& buffer_size,
-                            const Glib::ustring& type)
-#else
-void Pixbuf::save_to_buffer(gchar*& buffer, gsize& buffer_size,
-                            const Glib::ustring& type, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-
-  gdk_pixbuf_save_to_buffer(
-      gobj(), &buffer, &buffer_size,
-      type.c_str(),
-      &gerror, NULL);
+      &error);
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Glib::Error::throw_exception(error);
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Pixbuf::save_to_buffer(gchar*& buffer, gsize& buffer_size,
                             const Glib::ustring& type,
                             const Glib::StringArrayHandle& option_keys,
                             const Glib::StringArrayHandle& option_values)
-#else
-void Pixbuf::save_to_buffer(gchar*& buffer, gsize& buffer_size,
-                            const Glib::ustring& type,
-                            const Glib::StringArrayHandle& option_keys,
-                            const Glib::StringArrayHandle& option_values, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
+  GError* error = 0;
 
   gdk_pixbuf_save_to_bufferv(
       gobj(), &buffer, &buffer_size,
       type.c_str(),
       const_cast<char**>(option_keys.data()), const_cast<char**>(option_values.data()),
-      &gerror);
+      &error);
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
+  if(error)
+    Glib::Error::throw_exception(error);
 }
 
 Pixbuf::SListHandle_PixbufFormat Pixbuf::get_formats()
@@ -286,18 +255,10 @@ Gdk::PixbufError::Code Gdk::PixbufError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Gdk::PixbufError::throw_func(GError* gobject)
 {
   throw Gdk::PixbufError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Gdk::PixbufError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Gdk::PixbufError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 // static
 GType Glib::Value<Gdk::PixbufError::Code>::value_type()
@@ -349,19 +310,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Pixbuf_Class::wrap_new(GObject* object)
 {
@@ -422,82 +372,16 @@ Glib::RefPtr<Pixbuf> Pixbuf::create(Colorspace colorspace, bool has_alpha, int b
   return Glib::wrap(gdk_pixbuf_new(((GdkColorspace)(colorspace)), static_cast<int>(has_alpha), bits_per_sample, width, height));
 }
 
-
 Glib::RefPtr<Pixbuf> Pixbuf::create_subpixbuf(const Glib::RefPtr<Pixbuf>& src_pixbuf, int src_x, int src_y, int width, int height)
 {
   return Glib::wrap(gdk_pixbuf_new_subpixbuf(Glib::unwrap(src_pixbuf), src_x, src_y, width, height));
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename)
-#else
-Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Glib::RefPtr<Pixbuf> retvalue = Glib::wrap(gdk_pixbuf_new_from_file(filename.c_str(), &(gerror)));
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-}
-
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename, int width, int height, bool preserve_aspect_ratio)
-#else
-Glib::RefPtr<Pixbuf> Pixbuf::create_from_file(const std::string& filename, int width, int height, bool preserve_aspect_ratio, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Glib::RefPtr<Pixbuf> retvalue = Glib::wrap(gdk_pixbuf_new_from_file_at_scale(filename.c_str(), width, height, static_cast<int>(preserve_aspect_ratio), &(gerror)));
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-}
-
-
 Glib::RefPtr<Pixbuf> Pixbuf::create_from_xpm_data(const char *const * data)
 {
   return Glib::wrap(gdk_pixbuf_new_from_xpm_data(const_cast<const char**>(data)));
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<Pixbuf> Pixbuf::create_from_inline(int data_length, const guint8* data, bool copy_pixels)
-#else
-Glib::RefPtr<Pixbuf> Pixbuf::create_from_inline(int data_length, const guint8* data, bool copy_pixels, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Glib::RefPtr<Pixbuf> retvalue = Glib::wrap(gdk_pixbuf_new_from_inline(data_length, data, static_cast<int>(copy_pixels), &(gerror)));
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-}
-
-
 Colorspace Pixbuf::get_colorspace() const
 {
   return ((Colorspace)(gdk_pixbuf_get_colorspace(const_cast<GdkPixbuf*>(gobj()))));
@@ -540,7 +424,7 @@ int Pixbuf::get_rowstride() const
 
 void Pixbuf::fill(guint32 pixel)
 {
-gdk_pixbuf_fill(gobj(), pixel); 
+  gdk_pixbuf_fill(gobj(), pixel);
 }
 
 Glib::RefPtr<Gdk::Pixbuf> Pixbuf::add_alpha(bool substitute_color, guint8 r, guint8 g, guint8 b) const
@@ -550,27 +434,27 @@ Glib::RefPtr<Gdk::Pixbuf> Pixbuf::add_alpha(bool substitute_color, guint8 r, gui
 
 void Pixbuf::copy_area(int src_x, int src_y, int width, int height, const Glib::RefPtr<Gdk::Pixbuf>& dest_pixbuf, int dest_x, int dest_y) const
 {
-gdk_pixbuf_copy_area(const_cast<GdkPixbuf*>(gobj()), src_x, src_y, width, height, Glib::unwrap(dest_pixbuf), dest_x, dest_y); 
+  gdk_pixbuf_copy_area(const_cast<GdkPixbuf*>(gobj()), src_x, src_y, width, height, Glib::unwrap(dest_pixbuf), dest_x, dest_y);
 }
 
 void Pixbuf::saturate_and_pixelate(const Glib::RefPtr<Gdk::Pixbuf>& dest, float saturation, bool pixelate) const
 {
-gdk_pixbuf_saturate_and_pixelate(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), saturation, static_cast<int>(pixelate)); 
+  gdk_pixbuf_saturate_and_pixelate(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), saturation, static_cast<int>(pixelate));
 }
 
 void Pixbuf::scale(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type) const
 {
-gdk_pixbuf_scale(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type))); 
+  gdk_pixbuf_scale(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)));
 }
 
 void Pixbuf::composite(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha) const
 {
-gdk_pixbuf_composite(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)), overall_alpha); 
+  gdk_pixbuf_composite(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)), overall_alpha);
 }
 
 void Pixbuf::composite_color(const Glib::RefPtr<Gdk::Pixbuf>& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, guint32 color1, guint32 color2) const
 {
-gdk_pixbuf_composite_color(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)), overall_alpha, check_x, check_y, check_size, color1, color2); 
+  gdk_pixbuf_composite_color(const_cast<GdkPixbuf*>(gobj()), Glib::unwrap(dest), dest_x, dest_y, dest_width, dest_height, offset_x, offset_y, scale_x, scale_y, ((GdkInterpType)(interp_type)), overall_alpha, check_x, check_y, check_size, color1, color2);
 }
 
 Glib::RefPtr<Gdk::Pixbuf> Pixbuf::scale_simple(int dest_width, int dest_height, InterpType interp_type) const
@@ -595,17 +479,17 @@ Glib::RefPtr<Gdk::Pixbuf> Pixbuf::flip(bool horizontal) const
 
 void Pixbuf::render_threshold_alpha(const Glib::RefPtr<Gdk::Bitmap>& bitmap, int src_x, int src_y, int dest_x, int dest_y, int width, int height, int alpha_threshold)
 {
-gdk_pixbuf_render_threshold_alpha(gobj(), Glib::unwrap(bitmap), src_x, src_y, dest_x, dest_y, width, height, alpha_threshold); 
+  gdk_pixbuf_render_threshold_alpha(gobj(), Glib::unwrap(bitmap), src_x, src_y, dest_x, dest_y, width, height, alpha_threshold);
 }
 
 void Pixbuf::render_to_drawable(const Glib::RefPtr<Drawable>& drawable, const Glib::RefPtr<Gdk::GC>& gc, int src_x, int src_y, int dest_x, int dest_y, int width, int height, RgbDither dither, int x_dither, int y_dither)
 {
-gdk_pixbuf_render_to_drawable(gobj(), Glib::unwrap(drawable), Glib::unwrap(gc), src_x, src_y, dest_x, dest_y, width, height, ((GdkRgbDither)(dither)), x_dither, y_dither); 
+  gdk_pixbuf_render_to_drawable(gobj(), Glib::unwrap(drawable), Glib::unwrap(gc), src_x, src_y, dest_x, dest_y, width, height, ((GdkRgbDither)(dither)), x_dither, y_dither);
 }
 
 void Pixbuf::render_to_drawable_alpha(const Glib::RefPtr<Drawable>& drawable, int src_x, int src_y, int dest_x, int dest_y, int width, int height, PixbufAlphaMode alpha_mode, int alpha_threshold, RgbDither dither, int x_dither, int y_dither)
 {
-gdk_pixbuf_render_to_drawable_alpha(gobj(), Glib::unwrap(drawable), src_x, src_y, dest_x, dest_y, width, height, ((GdkPixbufAlphaMode)(alpha_mode)), alpha_threshold, ((GdkRgbDither)(dither)), x_dither, y_dither); 
+  gdk_pixbuf_render_to_drawable_alpha(gobj(), Glib::unwrap(drawable), src_x, src_y, dest_x, dest_y, width, height, ((GdkPixbufAlphaMode)(alpha_mode)), alpha_threshold, ((GdkRgbDither)(dither)), x_dither, y_dither);
 }
 
 Glib::ustring Pixbuf::get_option(const Glib::ustring& key) const
@@ -614,13 +498,6 @@ Glib::ustring Pixbuf::get_option(const Glib::ustring& key) const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gdk
 
 
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbuf.h b/libs/gtkmm2/gdk/gdkmm/pixbuf.h
index fb4a066ef6..712020a8b1 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbuf.h
+++ b/libs/gtkmm2/gdk/gdkmm/pixbuf.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_PIXBUF_H
 #define _GDKMM_PIXBUF_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -192,14 +191,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
@@ -287,7 +279,7 @@ private:
   
 protected:
 
-  //TODO: Document these, based on the docs for the C functions.
+  //TODO: Documente these, based on the docs for the C functions.
   Pixbuf(const Glib::RefPtr<Drawable>& src, const Glib::RefPtr<Colormap>& cmap,
          int src_x, int src_y, int dest_x, int dest_y, int width, int height);
   Pixbuf(const Glib::RefPtr<Image>& src, const Glib::RefPtr<Colormap>& cmap,
@@ -350,23 +342,7 @@ public:
    * @throw Glib::FileError
    * @throw Gdk::PixbufError
    */
-  
-  /** Creates a new pixbuf by loading an image from a file.  The file format is
-   * detected automatically. If <tt>0</tt> is returned, then @a error  will be set.
-   * Possible errors are in the Gdk::PIXBUF_ERROR and G::FILE_ERROR domains.
-   * @param filename Name of file to load, in the GLib file name encoding.
-   * @param error Return location for an error.
-   * @return A newly-created pixbuf with a reference count of 1, or <tt>0</tt> if
-   * any of several error conditions occurred:  the file could not be opened,
-   * there was no loader for the file's format, there was not enough memory to
-   * allocate the image buffer, or the image file contained invalid data.
-   */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename);
-#else
-  static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   
   /** Creates a new pixbuf by loading an image from a file. The file format is detected automatically.
    * The image will be scaled to fit in the requested size.
@@ -378,38 +354,8 @@ public:
    * @throw Glib::FileError
    * @throw Gdk::PixbufError
    */
-  
-  /** Creates a new pixbuf by loading an image from a file.  The file format is
-   * detected automatically. If <tt>0</tt> is returned, then @a error  will be set.
-   * Possible errors are in the Gdk::PIXBUF_ERROR and G::FILE_ERROR domains.
-   * The image will be scaled to fit in the requested size, optionally preserving
-   * the image's aspect ratio. 
-   * 
-   * When preserving the aspect ratio, a @a width  of -1 will cause the image
-   * to be scaled to the exact given height, and a @a height  of -1 will cause
-   * the image to be scaled to the exact given width. When not preserving
-   * aspect ratio, a @a width  or @a height  of -1 means to not scale the image 
-   * at all in that dimension. Negative values for @a width  and @a height  are 
-   * allowed since 2.8.
-   * @param filename Name of file to load, in the GLib file name encoding.
-   * @param width The width the image should have or -1 to not constrain the width.
-   * @param height The height the image should have or -1 to not constrain the height.
-   * @param preserve_aspect_ratio <tt>true</tt> to preserve the image's aspect ratio.
-   * @param error Return location for an error.
-   * @return A newly-created pixbuf with a reference count of 1, or <tt>0</tt> 
-   * if any of several error conditions occurred:  the file could not be opened,
-   * there was no loader for the file's format, there was not enough memory to
-   * allocate the image buffer, or the image file contained invalid data.
-   * 
-   * @newin2p6.
-   */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename, int width, int height, bool preserve_aspect_ratio = true);
-#else
-  static Glib::RefPtr<Pixbuf> create_from_file(const std::string& filename, int width, int height, bool preserve_aspect_ratio, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-   //gdk_pixbuf_new_from_file_at_size() just calls gdk_pixbuf_new_from_file_at_scale().
+  
 
   /** Creates a new Gdk::Pixbuf out of in-memory image data.
    * Currently only RGB images with 8 bits per sample are supported.
@@ -482,55 +428,10 @@ public:
    * to @a data for the resulting pixbuf.
    * @throw Gdk::PixbufError
    */
-  
-  /** Create a Gdk::Pixbuf from a flat representation that is suitable for
-   * storing as inline data in a program. This is useful if you want to
-   * ship a program with images, but don't want to depend on any
-   * external files.
-   * 
-   * GTK+ ships with a program called &lt;command&gt;gdk-pixbuf-csource&lt;/command&gt; 
-   * which allows for conversion of Gdk::Pixbufs into such a inline representation.
-   * In almost all cases, you should pass the &lt;option&gt;--raw&lt;/option&gt; flag to
-   * &lt;command&gt;gdk-pixbuf-csource&lt;/command&gt;. A sample invocation would be:
-   * 
-   * @code
-   * gdk-pixbuf-csource --raw --name=myimage_inline myimage.png
-   * @endcode
-   * 
-   * For the typical case where the inline pixbuf is read-only static data,
-   * you don't need to copy the pixel data unless you intend to write to
-   * it, so you can pass <tt>false</tt> for @a copy_pixels .  (If you pass 
-   * &lt;option&gt;--rle&lt;/option&gt; to &lt;command&gt;gdk-pixbuf-csource&lt;/command&gt;, a copy 
-   * will be made even if @a copy_pixels  is <tt>false</tt>, so using this option is 
-   * generally a bad idea.)
-   * 
-   * If you create a pixbuf from const inline data compiled into your
-   * program, it's probably safe to ignore errors and disable length checks, 
-   * since things will always succeed:
-   * @code
-   * pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, <tt>false</tt>, <tt>0</tt>);
-   * @endcode
-   * 
-   * For non-const inline data, you could get out of memory. For untrusted 
-   * inline data located at runtime, you could have corrupt inline data in 
-   * addition.
-   * @param data_length Length in bytes of the @a data  argument or -1 to 
-   * disable length checks.
-   * @param data Byte data containing a serialized Gdk::Pixdata structure.
-   * @param copy_pixels Whether to copy the pixel data, or use direct pointers
-   *  @a data  for the resulting pixbuf.
-   * @param error G::Error return location, may be <tt>0</tt> to ignore errors.
-   * @return A newly-created Gdk::Pixbuf structure with a reference,
-   * count of 1, or <tt>0</tt> if an error occurred.
-   */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static Glib::RefPtr<Pixbuf> create_from_inline(int data_length, const guint8* data,
                                                  bool copy_pixels = false);
-#else
-  static Glib::RefPtr<Pixbuf> create_from_inline(int data_length, const guint8* data, bool copy_pixels, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
+  
   /** Queries the color space of a pixbuf.
    * @return Color space.
    */
@@ -584,56 +485,21 @@ public:
    */
   void fill(guint32 pixel);
 
-  /** Saves pixbuf to a file in format @a type. 
-   * By default, "jpeg", "png", "ico" and "bmp" are possible file formats to save in, but more formats may be installed.
-   * TThe list of all writable formats can be determined by using Gdk::Pixbuf::get_formats() with 
-   * Gdk::PixbufFormat::is_writable().
-   *
-   * @param filename The path of the file to be created.
-   * @param type The file type.
-   *
+  /** Save an image file.
    * @throw Glib::FileError
    * @throw Gdk::PixbufError
    */
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   void save(const std::string& filename, const Glib::ustring& type);
-  #else
-  void save(const std::string& filename, const Glib::ustring& type, std::auto_ptr<Glib::Error>& error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
   
 
-  /** Saves pixbuf to a file in format @a type. 
-   * By default, "jpeg", "png", "ico" and "bmp" are possible file formats to save in, but more formats may be installed.
-   * TThe list of all writable formats can be determined by using Gdk::Pixbuf::get_formats() with 
-   * Gdk::PixbufFormat::is_writable().
-   *
-   * The @a option_keys and @option_values, if not empty, should contain pairs of strings that modify the save parameters. 
-   * For example,  "quality", "100".
-   *
-   * Currently only a few parameters exist. JPEG images can be saved with a "quality" parameter; 
-   * its value should be in the range [0,100]. Text chunks can be attached to PNG images by specifying parameters of the 
-   * form "tEXt::key", where key is an ASCII string of length 1-79. The values are UTF-8 encoded strings. ICO images can be 
-   * saved in depth 16, 24, or 32, by using the "depth" parameter. When the ICO saver is given "x_hot" and "y_hot" 
-   * parameters, it produces a CUR instead of an ICO.  
-   *
-   * @param filename The path of the file to be created.
-   * @param type The file type.
-   * @param option_keys
-   * @param option_values
-   *
+  /** Save an image file.
    * @throw Glib::FileError
    * @throw Gdk::PixbufError
    */
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   void save(const std::string& filename, const Glib::ustring& type,
             const Glib::StringArrayHandle& option_keys,
             const Glib::StringArrayHandle& option_values);
-  #else
-  void save(const std::string& filename, const Glib::ustring& type,
-            const Glib::StringArrayHandle& option_keys,
-            const Glib::StringArrayHandle& option_values, std::auto_ptr<Glib::Error>& error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
+  
   
 /* TODO:
 typedef gboolean (*GdkPixbufSaveFunc)   (const gchar *buf,
@@ -658,47 +524,10 @@ gboolean gdk_pixbuf_save_to_callbackv   (GdkPixbuf  *pixbuf,
 
 */
 
-  /* Saves the pixbuf to a new buffer in format @a type.
-   * Note that the buffer is not nul-terminated and may contain embedded nulls.
-   * @see save().
-   *
-   * @param buffer This will be set to the address of a new buffer.
-   * @param size This will be set to the size of the @a buffer.
-   * @param type Currently "jpeg", "png", "ico" or "bmp".
-   *
-   * @throw Glib::FileError
-   * @throw Gdk::PixbufError
-   */
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
-                      const Glib::ustring& type = "png");
-  #else
-  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
-                      const Glib::ustring& type, std::auto_ptr<Glib::Error>& error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-                      
-  /* Saves the pixbuf to a new buffer in format @a type.
-   * Note that the buffer is not nul-terminated and may contain embedded nulls.
-   * @see save().
-   *
-   * @param buffer This will be set to the address of a new buffer.
-   * @param size This will be set to the size of the @a buffer.
-   * @param type Currently "jpeg", "png", "ico" or "bmp".
-   *
-   * @throw Glib::FileError
-   * @throw Gdk::PixbufError
-   */
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   void save_to_buffer(gchar*& buffer, gsize& buffer_size,
                       const Glib::ustring& type,
                       const Glib::StringArrayHandle& option_keys,
                       const Glib::StringArrayHandle& option_values);
-  #else
-  void save_to_buffer(gchar*& buffer, gsize& buffer_size,
-                      const Glib::ustring& type,
-                      const Glib::StringArrayHandle& option_keys,
-                      const Glib::StringArrayHandle& option_values, std::auto_ptr<Glib::Error>& error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
   
                                          
   /** Takes an existing pixbuf and adds an alpha channel to it.
@@ -903,7 +732,7 @@ gboolean gdk_pixbuf_save_to_callbackv   (GdkPixbuf  *pixbuf,
    * @param angle The angle to rotate by.
    * @return A new pixbuf
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<Gdk::Pixbuf> rotate_simple(PixbufRotation angle) const;
   
@@ -912,7 +741,7 @@ gboolean gdk_pixbuf_save_to_callbackv   (GdkPixbuf  *pixbuf,
    * @param horizontal <tt>true</tt> to flip horizontally, <tt>false</tt> to flip vertically.
    * @return A new pixbuf.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<Gdk::Pixbuf> flip(bool horizontal = true) const;
 
@@ -1028,17 +857,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimation.cc b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.cc
index 4f9421f301..a558a55044 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufanimation.cc
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/pixbufanimation.h>
 #include <gdkmm/private/pixbufanimation_p.h>
 
@@ -88,19 +87,8 @@ void PixbufAnimation_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* PixbufAnimation_Class::wrap_new(GObject* object)
 {
@@ -162,30 +150,23 @@ Glib::RefPtr<Pixbuf> PixbufAnimation::get_static_image()
 {
 
   Glib::RefPtr<Pixbuf> retvalue = Glib::wrap(gdk_pixbuf_animation_get_static_image(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<PixbufAnimationIter> PixbufAnimation::get_iter(const GTimeVal* start_time)
 {
 
   Glib::RefPtr<PixbufAnimationIter> retvalue = Glib::wrap(gdk_pixbuf_animation_get_iter(gobj(), start_time));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gdk
 
 
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimation.h b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.h
index c30d72eae0..dd5afec672 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufanimation.h
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimation.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_PIXBUFANIMATION_H
 #define _GDKMM_PIXBUFANIMATION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -168,17 +167,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.cc b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.cc
index 404a0317b9..60046e4eff 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.cc
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/pixbufanimationiter.h>
 #include <gdkmm/private/pixbufanimationiter_p.h>
 
@@ -75,19 +74,8 @@ void PixbufAnimationIter_Class::class_init_function(void* g_class, void* class_d
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* PixbufAnimationIter_Class::wrap_new(GObject* object)
 {
@@ -130,13 +118,6 @@ GType PixbufAnimationIter::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gdk
 
 
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.h b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.h
index 7223a4baec..ceba0da1e9 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.h
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufanimationiter.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_PIXBUFANIMATIONITER_H
 #define _GDKMM_PIXBUFANIMATIONITER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -94,17 +93,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufformat.cc b/libs/gtkmm2/gdk/gdkmm/pixbufformat.cc
index da97fac330..63dc4c43a4 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufformat.cc
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufformat.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/pixbufformat.h>
 #include <gdkmm/private/pixbufformat_p.h>
 
@@ -105,7 +104,7 @@ bool PixbufFormat::is_disabled() const
 
 void PixbufFormat::set_disabled(bool disabled)
 {
-gdk_pixbuf_format_set_disabled(gobj(), static_cast<int>(disabled)); 
+  gdk_pixbuf_format_set_disabled(gobj(), static_cast<int>(disabled));
 }
 
 Glib::ustring PixbufFormat::get_license() const
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufformat.h b/libs/gtkmm2/gdk/gdkmm/pixbufformat.h
index bff60da222..b9adddf08d 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufformat.h
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufformat.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_PIXBUFFORMAT_H
 #define _GDKMM_PIXBUFFORMAT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -59,14 +58,14 @@ public:
   /** Returns the name of the format.
    * @return The name of the format. 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::ustring get_name() const;
   
   /** Returns a description of the format.
    * @return A description of the format.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::ustring get_description() const;
   
@@ -74,7 +73,7 @@ public:
    * @return A <tt>0</tt>-terminated array of mime types which must be freed with 
    * Glib::strfreev() when it is no longer needed.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::StringArrayHandle get_mime_types() const;
   
@@ -83,14 +82,14 @@ public:
    * @return A <tt>0</tt>-terminated array of filename extensions which must be
    * freed with Glib::strfreev() when it is no longer needed.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::StringArrayHandle get_extensions() const;
   
   /** Returns whether pixbufs can be saved in the given format.
    * @return Whether pixbufs can be saved in the given format.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool is_writable() const;
   
@@ -101,7 +100,7 @@ public:
    * resulting pixbuf to the desired size.
    * @return Whether this image format is scalable.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool is_scalable() const;
   
@@ -109,7 +108,7 @@ public:
    * gdk_pixbuf_format_set_disabled().
    * @return Whether this image format is disabled.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool is_disabled() const;
   
@@ -118,7 +117,7 @@ public:
    * images. Applications can use this to avoid using image loaders 
    * with an inappropriate license, see gdk_pixbuf_format_get_license().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param disabled <tt>true</tt> to disable the format @a format .
    */
   void set_disabled(bool disabled = true);
@@ -129,7 +128,7 @@ public:
    * or "other" to indicate some other license.
    * @return A string describing the license of @a format . 
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_license() const;
 
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufloader.cc b/libs/gtkmm2/gdk/gdkmm/pixbufloader.cc
index cd0022326b..41af07e520 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufloader.cc
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufloader.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/pixbufloader.h>
 #include <gdkmm/private/pixbufloader_p.h>
 
@@ -34,15 +33,15 @@ namespace
 /* We use this helper function in the constructor to be able to throw
  * before the base class' (Glib::Object) constructor is called.
  */
-static GdkPixbufLoader* pixbuf_loader_create_with_type(const Glib::ustring& image_type, bool mime_type)
+GdkPixbufLoader* pixbuf_loader_create_with_type(const Glib::ustring& image_type, bool mime_type)
 {
   GError* error = 0;
-  GdkPixbufLoader* loader = 0;
-
+  GdkPixbufLoader *const loader = 0;
+  
   if(mime_type)
-    loader = gdk_pixbuf_loader_new_with_mime_type(image_type.c_str(), &error);
+    gdk_pixbuf_loader_new_with_mime_type(image_type.c_str(), &error);
   else
-    loader = gdk_pixbuf_loader_new_with_type(image_type.c_str(), &error);
+    gdk_pixbuf_loader_new_with_type(image_type.c_str(), &error);
 
   if(error)
     Glib::Error::throw_exception(error);
@@ -62,14 +61,31 @@ PixbufLoader::PixbufLoader(const Glib::ustring& image_type, bool mime_type)
   Glib::Object((GObject*) pixbuf_loader_create_with_type(image_type, mime_type))
 {}
 
+void PixbufLoader::write(const guint8* buf, gsize count)
+{
+  GError* error = 0;
+  gdk_pixbuf_loader_write(gobj(), buf, count, &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+}
+
+void PixbufLoader::close()
+{
+  GError* error = 0;
+  gdk_pixbuf_loader_close(gobj(), &error);
+
+  if(error)
+    Glib::Error::throw_exception(error);
+}
+
 } // namespace Gdk
 
 
 namespace
 {
 
-
-static const Glib::SignalProxyInfo PixbufLoader_signal_area_prepared_info =
+const Glib::SignalProxyInfo PixbufLoader_signal_area_prepared_info =
 {
   "area_prepared",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -77,7 +93,7 @@ static const Glib::SignalProxyInfo PixbufLoader_signal_area_prepared_info =
 };
 
 
-static void PixbufLoader_signal_area_updated_callback(GdkPixbufLoader* self, gint p0,gint p1,gint p2,gint p3,void* data)
+void PixbufLoader_signal_area_updated_callback(GdkPixbufLoader* self, gint p0,gint p1,gint p2,gint p3,void* data)
 {
   using namespace Gdk;
   typedef sigc::slot< void,int,int,int,int > SlotType;
@@ -85,27 +101,23 @@ static void PixbufLoader_signal_area_updated_callback(GdkPixbufLoader* self, gin
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 , p2
 , p3
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo PixbufLoader_signal_area_updated_info =
+const Glib::SignalProxyInfo PixbufLoader_signal_area_updated_info =
 {
   "area_updated",
   (GCallback) &PixbufLoader_signal_area_updated_callback,
@@ -113,7 +125,7 @@ static const Glib::SignalProxyInfo PixbufLoader_signal_area_updated_info =
 };
 
 
-static const Glib::SignalProxyInfo PixbufLoader_signal_closed_info =
+const Glib::SignalProxyInfo PixbufLoader_signal_closed_info =
 {
   "closed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -121,7 +133,7 @@ static const Glib::SignalProxyInfo PixbufLoader_signal_closed_info =
 };
 
 
-static void PixbufLoader_signal_size_prepared_callback(GdkPixbufLoader* self, gint p0,gint p1,void* data)
+void PixbufLoader_signal_size_prepared_callback(GdkPixbufLoader* self, gint p0,gint p1,void* data)
 {
   using namespace Gdk;
   typedef sigc::slot< void,int,int > SlotType;
@@ -129,32 +141,27 @@ static void PixbufLoader_signal_size_prepared_callback(GdkPixbufLoader* self, gi
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo PixbufLoader_signal_size_prepared_info =
+const Glib::SignalProxyInfo PixbufLoader_signal_size_prepared_info =
 {
   "size_prepared",
   (GCallback) &PixbufLoader_signal_size_prepared_callback,
   (GCallback) &PixbufLoader_signal_size_prepared_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -201,20 +208,12 @@ void PixbufLoader_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->area_prepared = &area_prepared_callback;
   klass->area_updated = &area_updated_callback;
   klass->closed = &closed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void PixbufLoader_Class::area_prepared_callback(GdkPixbufLoader* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -227,19 +226,15 @@ void PixbufLoader_Class::area_prepared_callback(GdkPixbufLoader* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_area_prepared();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -252,6 +247,7 @@ void PixbufLoader_Class::area_prepared_callback(GdkPixbufLoader* self)
       (*base->area_prepared)(self);
   }
 }
+
 void PixbufLoader_Class::area_updated_callback(GdkPixbufLoader* self, gint p0, gint p1, gint p2, gint p3)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -264,23 +260,19 @@ void PixbufLoader_Class::area_updated_callback(GdkPixbufLoader* self, gint p0, g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_area_updated(p0
 , p1
 , p2
 , p3
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -293,6 +285,7 @@ void PixbufLoader_Class::area_updated_callback(GdkPixbufLoader* self, gint p0, g
       (*base->area_updated)(self, p0, p1, p2, p3);
   }
 }
+
 void PixbufLoader_Class::closed_callback(GdkPixbufLoader* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -305,19 +298,15 @@ void PixbufLoader_Class::closed_callback(GdkPixbufLoader* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_closed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -330,7 +319,6 @@ void PixbufLoader_Class::closed_callback(GdkPixbufLoader* self)
       (*base->closed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* PixbufLoader_Class::wrap_new(GObject* object)
@@ -391,65 +379,27 @@ Glib::RefPtr<PixbufLoader> PixbufLoader::create(const Glib::ustring& image_type,
 }
 void PixbufLoader::set_size(int width, int height)
 {
-gdk_pixbuf_loader_set_size(gobj(), width, height); 
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-void PixbufLoader::write(const guint8* buf, gsize count)
-#else
-void PixbufLoader::write(const guint8* buf, gsize count, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  gdk_pixbuf_loader_write(gobj(), (buf), count, &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-void PixbufLoader::close()
-#else
-void PixbufLoader::close(std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  gdk_pixbuf_loader_close(gobj(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-
+  gdk_pixbuf_loader_set_size(gobj(), width, height);
 }
 
 Glib::RefPtr<Gdk::Pixbuf> PixbufLoader::get_pixbuf()
 {
 
   Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gdk_pixbuf_loader_get_pixbuf(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Gdk::PixbufAnimation> PixbufLoader::get_animation()
 {
 
   Glib::RefPtr<Gdk::PixbufAnimation> retvalue = Glib::wrap(gdk_pixbuf_loader_get_animation(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 PixbufFormat PixbufLoader::get_format() const
@@ -463,26 +413,22 @@ Glib::SignalProxy0< void > PixbufLoader::signal_area_prepared()
   return Glib::SignalProxy0< void >(this, &PixbufLoader_signal_area_prepared_info);
 }
 
-
 Glib::SignalProxy4< void,int,int,int,int > PixbufLoader::signal_area_updated()
 {
   return Glib::SignalProxy4< void,int,int,int,int >(this, &PixbufLoader_signal_area_updated_info);
 }
 
-
 Glib::SignalProxy0< void > PixbufLoader::signal_closed()
 {
   return Glib::SignalProxy0< void >(this, &PixbufLoader_signal_closed_info);
 }
 
-
 Glib::SignalProxy2< void,int,int > PixbufLoader::signal_size_prepared()
 {
   return Glib::SignalProxy2< void,int,int >(this, &PixbufLoader_signal_size_prepared_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gdk::PixbufLoader::on_area_prepared()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -492,6 +438,7 @@ void Gdk::PixbufLoader::on_area_prepared()
   if(base && base->area_prepared)
     (*base->area_prepared)(gobj());
 }
+
 void Gdk::PixbufLoader::on_area_updated(int x, int y, int width, int height)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -501,6 +448,7 @@ void Gdk::PixbufLoader::on_area_updated(int x, int y, int width, int height)
   if(base && base->area_updated)
     (*base->area_updated)(gobj(),x,y,width,height);
 }
+
 void Gdk::PixbufLoader::on_closed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -510,10 +458,6 @@ void Gdk::PixbufLoader::on_closed()
   if(base && base->closed)
     (*base->closed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/pixbufloader.h b/libs/gtkmm2/gdk/gdkmm/pixbufloader.h
index 1df9791c95..c89288740f 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixbufloader.h
+++ b/libs/gtkmm2/gdk/gdkmm/pixbufloader.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_PIXBUFLOADER_H
 #define _GDKMM_PIXBUFLOADER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -107,17 +106,12 @@ protected:
    * and here:
    * http://www.freedesktop.org/Software/shared-mime-info
    *
-   * The list of non-mime-type image formats depends on what image loaders
-   * are installed, but typically "png", "jpeg", "gif", "tiff" and 
-   * "xpm" are among the supported formats. To obtain the full list of
-   * supported image formats, call PixbufFormat::get_name() on each 
-   * of the PixbufFormats returned by Gdk::Pixbuf::get_formats().
-   *
    * @param image_type Name of the image format to be loaded with the image.
    * @param mime_type If this is true then the image_type is a MIME type.
    * @throw Gdk::PixbufError
    */
   explicit PixbufLoader(const Glib::ustring& image_type, bool mime_type = false);
+  //TODO: What non-mime-types names are possible?
 
 public:
 
@@ -142,12 +136,6 @@ public:
    * and here:
    * http://www.freedesktop.org/Software/shared-mime-info
    *
-   * The list of non-mime-type image formats depends on what image loaders
-   * are installed, but typically "png", "jpeg", "gif", "tiff" and 
-   * "xpm" are among the supported formats. To obtain the full list of
-   * supported image formats, call PixbufFormat::get_name() on each 
-   * of the PixbufFormats returned by Gdk::Pixbuf::get_formats().
-   *
    * @param image_type Name of the image format to be loaded with the image.
    * @param mime_type If this is true then the image_type is a MIME type.
    * @throw Gdk::PixbufError
@@ -164,13 +152,12 @@ public:
    * Attempts to set the desired image size  are ignored after the 
    * emission of the ::size_prepared signal.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param width The desired width of the image being loaded.
    * @param height The desired height of the image being loaded.
    */
   void set_size(int width, int height);
-
- 
+          
   /** Causes the pixbuf loader to parse the next @a count bytes of an image.
    * It will return if the data was loaded successfully, and throw an exception
    * if an error occurred. In the latter case, the loader will be closed, and
@@ -180,25 +167,8 @@ public:
    * @throw Gdk::PixbufError
    * @throw Glib::FileError
    */
-  
-  /** This will cause a pixbuf loader to parse the next @a count  bytes of
-   * an image.  It will return <tt>true</tt> if the data was loaded successfully,
-   * and <tt>false</tt> if an error occurred.  In the latter case, the loader
-   * will be closed, and will not accept further writes. If <tt>false</tt> is
-   * returned, @a error  will be set to an error from the Gdk::PIXBUF_ERROR
-   * or G::FILE_ERROR domains.
-   * @param buf Pointer to image data.
-   * @param count Length of the @a buf  buffer in bytes.
-   * @param error Return location for errors.
-   * @return <tt>true</tt> if the write was successful, or <tt>false</tt> if the loader
-   * cannot parse the buffer.
-   */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   void write(const guint8* buf, gsize count);
-#else
-  void write(const guint8* buf, gsize count, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+  
 
   /** Informs a pixbuf loader that no further writes with PixbufLoader::write()
    * will occur, so that it can free its internal loading structures.  Also,
@@ -209,26 +179,8 @@ public:
    * @throw Gdk::PixbufError
    * @throw Glib::FileError
    */
-  
-  /** Informs a pixbuf loader that no further writes with
-   * write() will occur, so that it can free its
-   * internal loading structures. Also, tries to parse any data that
-   * hasn't yet been parsed; if the remaining data is partial or
-   * corrupt, an error will be returned.  If <tt>false</tt> is returned, @a error 
-   * will be set to an error from the Gdk::PIXBUF_ERROR or G::FILE_ERROR
-   * domains. If you're just cancelling a load rather than expecting it
-   * to be finished, passing <tt>0</tt> for @a error  to ignore it is
-   * reasonable.
-   * @param error Return location for a G::Error, or <tt>0</tt> to ignore errors.
-   * @return <tt>true</tt> if all image data written so far was successfully
-   *             passed out via the update_area signal.
-   */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   void close();
-#else
-  void close(std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+  
 
   /** Queries the Gdk::Pixbuf that a pixbuf loader is currently creating.
    * In general it only makes sense to call this function after the
@@ -262,74 +214,23 @@ public:
    * @return A Gdk::PixbufFormat or <tt>0</tt>. The return value is owned 
    * by GdkPixbuf and should not be freed.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   PixbufFormat get_format() const;
 
-  /** This signal is emitted when the pixbuf loader has allocated the 
-   * pixbuf in the desired size.  After this signal is emitted, 
-   * applications can call get_pixbuf() to fetch 
-   * the partially-loaded pixbuf.
-   */ 
   
-/**
-   * @par Prototype:
-   * <tt>void %area_prepared()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_area_prepared();
 
-
-  /** This signal is emitted when a significant area of the image being
-   * loaded has been updated.  Normally it means that a complete
-   * scanline has been read in, but it could be a different area as
-   * well.  Applications can use this signal to know when to repaint
-   * areas of an image that is being loaded.
-   *
-   * @param X offset of upper-left corner of the updated area.
-   * @param y Y offset of upper-left corner of the updated area.
-   * @param width Width of updated area.
-   * @param height Height of updated area.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %area_updated(int x, int y, int width, int height)</tt>
-   */
-
   Glib::SignalProxy4< void,int,int,int,int > signal_area_updated();
 
-
-  /** This signal is emitted when close() is called.
-   * It can be used by different parts of an application to receive
-   * notification when an image loader is closed by the code that
-   * drives it.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %closed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_closed();
 
-
+  
   //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
   //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
-  /** This signal is emitted when the pixbuf loader has been fed the
-   * initial amount of data that is required to figure out the size
-   * of the image that it will create.  Applications can call  
-   * set_size() in response to this signal to set
-   * the desired size to which the image should be scaled.
-   *
-   * @param width The original width of the image.
-   * @param height The original height of the image
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %size_prepared(int width, int height)</tt>
-   */
 
   Glib::SignalProxy2< void,int,int > signal_size_prepared();
 
@@ -338,20 +239,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_area_prepared();
   virtual void on_area_updated(int x, int y, int width, int height);
   virtual void on_closed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/pixmap.cc b/libs/gtkmm2/gdk/gdkmm/pixmap.cc
index 6dd0a8be83..a64cfb6aed 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixmap.cc
+++ b/libs/gtkmm2/gdk/gdkmm/pixmap.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/pixmap.h>
 #include <gdkmm/private/pixmap_p.h>
 
@@ -257,19 +256,8 @@ void Pixmap_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 /* The implementation: */
 
@@ -327,13 +315,6 @@ Glib::RefPtr<Pixmap> Pixmap::create(const Glib::RefPtr<Display>& display, Native
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gdk
 
 
diff --git a/libs/gtkmm2/gdk/gdkmm/pixmap.h b/libs/gtkmm2/gdk/gdkmm/pixmap.h
index b544b063ee..6a7a1d978d 100644
--- a/libs/gtkmm2/gdk/gdkmm/pixmap.h
+++ b/libs/gtkmm2/gdk/gdkmm/pixmap.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_PIXMAP_H
 #define _GDKMM_PIXMAP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -176,17 +175,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/private/bitmap_p.h b/libs/gtkmm2/gdk/gdkmm/private/bitmap_p.h
index fc789f605c..13a2e31932 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/bitmap_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/bitmap_p.h
@@ -2,10 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_BITMAP_P_H
 #define _GDKMM_BITMAP_P_H
-
-
 #include <gdkmm/private/pixmap_p.h>
-
-
 #endif /* _GDKMM_BITMAP_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/color_p.h b/libs/gtkmm2/gdk/gdkmm/private/color_p.h
index 1ba0df5e77..10e8370c05 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/color_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/color_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_COLOR_P_H
 #define _GDKMM_COLOR_P_H
-
-
 #endif /* _GDKMM_COLOR_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/colormap_p.h b/libs/gtkmm2/gdk/gdkmm/private/colormap_p.h
index ffdbf36a1f..3ceb776d16 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/colormap_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/colormap_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_COLORMAP_P_H
 #define _GDKMM_COLORMAP_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_COLORMAP_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/cursor_p.h b/libs/gtkmm2/gdk/gdkmm/private/cursor_p.h
index 75fab182b0..5400e45e0a 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/cursor_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/cursor_p.h
@@ -2,10 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_CURSOR_P_H
 #define _GDKMM_CURSOR_P_H
-
-
 #include <glibmm/private/object_p.h>
-
-
 #endif /* _GDKMM_CURSOR_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/device_p.h b/libs/gtkmm2/gdk/gdkmm/private/device_p.h
index 45f285566b..f19b9c8ccd 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/device_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/device_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_DEVICE_P_H
 #define _GDKMM_DEVICE_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_DEVICE_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/display_p.h b/libs/gtkmm2/gdk/gdkmm/private/display_p.h
index 14c310c782..0b5ba089e0 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/display_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/display_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_DISPLAY_P_H
 #define _GDKMM_DISPLAY_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 closed_callback(GdkDisplay* self, gboolean p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_DISPLAY_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/displaymanager_p.h b/libs/gtkmm2/gdk/gdkmm/private/displaymanager_p.h
index 547ad83a47..25ff018c44 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/displaymanager_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/displaymanager_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_DISPLAYMANAGER_P_H
 #define _GDKMM_DISPLAYMANAGER_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 display_opened_callback(GdkDisplayManager* self, GdkDisplay* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_DISPLAYMANAGER_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/dragcontext_p.h b/libs/gtkmm2/gdk/gdkmm/private/dragcontext_p.h
index 6c851e81f6..13dfd57ccc 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/dragcontext_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/dragcontext_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_DRAGCONTEXT_P_H
 #define _GDKMM_DRAGCONTEXT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_DRAGCONTEXT_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/drawable_p.h b/libs/gtkmm2/gdk/gdkmm/private/drawable_p.h
index 30d3187935..59e22d083e 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/drawable_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/drawable_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_DRAWABLE_P_H
 #define _GDKMM_DRAWABLE_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_DRAWABLE_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/event_p.h b/libs/gtkmm2/gdk/gdkmm/private/event_p.h
index df8fe3d0a3..999db9b7fc 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/event_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/event_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_EVENT_P_H
 #define _GDKMM_EVENT_P_H
-
-
 #endif /* _GDKMM_EVENT_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/gc_p.h b/libs/gtkmm2/gdk/gdkmm/private/gc_p.h
index 1631fc501d..82725a3a1a 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/gc_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/gc_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_GC_P_H
 #define _GDKMM_GC_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_GC_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/image_p.h b/libs/gtkmm2/gdk/gdkmm/private/image_p.h
index 4ebe7a763f..2b6fe88d3d 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/image_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/image_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_IMAGE_P_H
 #define _GDKMM_IMAGE_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_IMAGE_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbuf_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbuf_p.h
index 1d6de418bd..659bd0d8d7 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/pixbuf_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbuf_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_PIXBUF_P_H
 #define _GDKMM_PIXBUF_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_PIXBUF_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufanimation_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimation_p.h
index a70ee93465..ca03e440c2 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/pixbufanimation_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimation_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_PIXBUFANIMATION_P_H
 #define _GDKMM_PIXBUFANIMATION_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_PIXBUFANIMATION_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufanimationiter_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimationiter_p.h
index 259d5e222e..f7de22ffd8 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/pixbufanimationiter_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufanimationiter_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_PIXBUFANIMATIONITER_P_H
 #define _GDKMM_PIXBUFANIMATIONITER_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_PIXBUFANIMATIONITER_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufformat_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufformat_p.h
index 4d104b942d..6a0b196620 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/pixbufformat_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufformat_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_PIXBUFFORMAT_P_H
 #define _GDKMM_PIXBUFFORMAT_P_H
-
-
 #endif /* _GDKMM_PIXBUFFORMAT_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixbufloader_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixbufloader_p.h
index 7dfc5ac4eb..7bceceef72 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/pixbufloader_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixbufloader_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_PIXBUFLOADER_P_H
 #define _GDKMM_PIXBUFLOADER_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,23 +30,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 area_prepared_callback(GdkPixbufLoader* self);
   static void area_updated_callback(GdkPixbufLoader* self, gint p0, gint p1, gint p2, gint p3);
   static void closed_callback(GdkPixbufLoader* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_PIXBUFLOADER_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/pixmap_p.h b/libs/gtkmm2/gdk/gdkmm/private/pixmap_p.h
index 048297f37c..149ed76a07 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/pixmap_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/pixmap_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_PIXMAP_P_H
 #define _GDKMM_PIXMAP_P_H
-
-
 #include <gdkmm/private/drawable_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_PIXMAP_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/rectangle_p.h b/libs/gtkmm2/gdk/gdkmm/private/rectangle_p.h
index 9b3f64ee94..51088336bb 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/rectangle_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/rectangle_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_RECTANGLE_P_H
 #define _GDKMM_RECTANGLE_P_H
-
-
 #endif /* _GDKMM_RECTANGLE_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/region_p.h b/libs/gtkmm2/gdk/gdkmm/private/region_p.h
index 4623ed285d..b0a7f8cdf2 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/region_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/region_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_REGION_P_H
 #define _GDKMM_REGION_P_H
-
-
 #endif /* _GDKMM_REGION_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/rgbcmap_p.h b/libs/gtkmm2/gdk/gdkmm/private/rgbcmap_p.h
index d290d5c492..d5845141c4 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/rgbcmap_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/rgbcmap_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_RGBCMAP_P_H
 #define _GDKMM_RGBCMAP_P_H
-
-
 #endif /* _GDKMM_RGBCMAP_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/screen_p.h b/libs/gtkmm2/gdk/gdkmm/private/screen_p.h
index 320b05df0b..9888f6c9db 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/screen_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/screen_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_SCREEN_P_H
 #define _GDKMM_SCREEN_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 size_changed_callback(GdkScreen* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_SCREEN_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/types_p.h b/libs/gtkmm2/gdk/gdkmm/private/types_p.h
index 701f260a38..474d473ad8 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/types_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/types_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_TYPES_P_H
 #define _GDKMM_TYPES_P_H
-
-
 #endif /* _GDKMM_TYPES_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/visual_p.h b/libs/gtkmm2/gdk/gdkmm/private/visual_p.h
index 362fb1a62b..b11005c9db 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/visual_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/visual_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_VISUAL_P_H
 #define _GDKMM_VISUAL_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_VISUAL_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/private/window_p.h b/libs/gtkmm2/gdk/gdkmm/private/window_p.h
index 803c224d65..c9fc8a9e85 100644
--- a/libs/gtkmm2/gdk/gdkmm/private/window_p.h
+++ b/libs/gtkmm2/gdk/gdkmm/private/window_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GDKMM_WINDOW_P_H
 #define _GDKMM_WINDOW_P_H
-
-
 #include <gdkmm/private/drawable_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gdk
 
-
 #endif /* _GDKMM_WINDOW_P_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/rectangle.cc b/libs/gtkmm2/gdk/gdkmm/rectangle.cc
index 89646a4e7c..a59a22bd75 100644
--- a/libs/gtkmm2/gdk/gdkmm/rectangle.cc
+++ b/libs/gtkmm2/gdk/gdkmm/rectangle.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/rectangle.h>
 #include <gdkmm/private/rectangle_p.h>
 
@@ -115,46 +114,46 @@ Rectangle::Rectangle(const GdkRectangle* gobject)
 }
 
 
- int Rectangle::get_x() const
+int Rectangle::get_x() const
 {
   return gobj()->x;
 }
- 
- void Rectangle::set_x(const int& value)
+
+void Rectangle::set_x(const int& value)
 {
   gobj()->x = value;
 }
- 
- int Rectangle::get_y() const
+
+int Rectangle::get_y() const
 {
   return gobj()->y;
 }
- 
- void Rectangle::set_y(const int& value)
+
+void Rectangle::set_y(const int& value)
 {
   gobj()->y = value;
 }
- 
- int Rectangle::get_width() const
+
+int Rectangle::get_width() const
 {
   return gobj()->width;
 }
- 
- void Rectangle::set_width(const int& value)
+
+void Rectangle::set_width(const int& value)
 {
   gobj()->width = value;
 }
- 
- int Rectangle::get_height() const
+
+int Rectangle::get_height() const
 {
   return gobj()->height;
 }
- 
- void Rectangle::set_height(const int& value)
+
+void Rectangle::set_height(const int& value)
 {
   gobj()->height = value;
 }
- 
+
 
 } // namespace Gdk
 
diff --git a/libs/gtkmm2/gdk/gdkmm/rectangle.h b/libs/gtkmm2/gdk/gdkmm/rectangle.h
index 4444645657..5a92e1b22d 100644
--- a/libs/gtkmm2/gdk/gdkmm/rectangle.h
+++ b/libs/gtkmm2/gdk/gdkmm/rectangle.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_RECTANGLE_H
 #define _GDKMM_RECTANGLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -72,15 +71,15 @@ public:
 
   bool has_zero_area() const;
 
-   int get_x() const;
-    void set_x(const int& value);
-    int get_y() const;
-    void set_y(const int& value);
-    int get_width() const;
-    void set_width(const int& value);
-    int get_height() const;
-    void set_height(const int& value);
- 
+  int get_x() const;
+  void set_x(const int& value);
+  int get_y() const;
+  void set_y(const int& value);
+  int get_width() const;
+  void set_width(const int& value);
+  int get_height() const;
+  void set_height(const int& value);
+
 
 };
 
@@ -110,6 +109,5 @@ class Value<Gdk::Rectangle> : public Glib::Value_Boxed<Gdk::Rectangle>
 
 } // namespace Glib
 
-
 #endif /* _GDKMM_RECTANGLE_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/region.cc b/libs/gtkmm2/gdk/gdkmm/region.cc
index b83c9beea7..7206c1e239 100644
--- a/libs/gtkmm2/gdk/gdkmm/region.cc
+++ b/libs/gtkmm2/gdk/gdkmm/region.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/region.h>
 #include <gdkmm/private/region_p.h>
 
@@ -152,7 +151,7 @@ GdkRegion* Region::gobj_copy() const
 
 void Region::get_clipbox(const Rectangle& rectangle)
 {
-gdk_region_get_clipbox(gobj(), const_cast<GdkRectangle*>(rectangle.gobj())); 
+  gdk_region_get_clipbox(gobj(), const_cast<GdkRectangle*>(rectangle.gobj()));
 }
 
 bool Region::empty()
@@ -172,42 +171,42 @@ OverlapType Region::rect_in(const Rectangle& rect)
 
 void Region::offset(int dx, int dy)
 {
-gdk_region_offset(gobj(), dx, dy); 
+  gdk_region_offset(gobj(), dx, dy);
 }
 
 void Region::shrink(int dx, int dy)
 {
-gdk_region_shrink(gobj(), dx, dy); 
+  gdk_region_shrink(gobj(), dx, dy);
 }
 
 void Region::union_with_rect(const Rectangle& rect)
 {
-gdk_region_union_with_rect(gobj(), const_cast<GdkRectangle*>(rect.gobj())); 
+  gdk_region_union_with_rect(gobj(), const_cast<GdkRectangle*>(rect.gobj()));
 }
 
 void Region::intersect(const Region& source2)
 {
-gdk_region_intersect(gobj(), const_cast<GdkRegion*>((source2).gobj())); 
+  gdk_region_intersect(gobj(), const_cast<GdkRegion*>((source2).gobj()));
 }
 
 void Region::union_(const Region& source2)
 {
-gdk_region_union(gobj(), const_cast<GdkRegion*>((source2).gobj())); 
+  gdk_region_union(gobj(), const_cast<GdkRegion*>((source2).gobj()));
 }
 
 void Region::subtract(const Region& source2)
 {
-gdk_region_subtract(gobj(), const_cast<GdkRegion*>((source2).gobj())); 
+  gdk_region_subtract(gobj(), const_cast<GdkRegion*>((source2).gobj()));
 }
 
 void Region::xor_(const Region& source2)
 {
-gdk_region_xor(gobj(), const_cast<GdkRegion*>((source2).gobj())); 
+  gdk_region_xor(gobj(), const_cast<GdkRegion*>((source2).gobj()));
 }
 
 void Region::spans_intersect_foreach(GdkSpan* spans, int n_spans, bool sorted, GdkSpanFunc function, gpointer data)
 {
-gdk_region_spans_intersect_foreach(gobj(), spans, n_spans, static_cast<int>(sorted), function, data); 
+  gdk_region_spans_intersect_foreach(gobj(), spans, n_spans, static_cast<int>(sorted), function, data);
 }
 
 
diff --git a/libs/gtkmm2/gdk/gdkmm/region.h b/libs/gtkmm2/gdk/gdkmm/region.h
index af0d2647f9..bcea009aa7 100644
--- a/libs/gtkmm2/gdk/gdkmm/region.h
+++ b/libs/gtkmm2/gdk/gdkmm/region.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_REGION_H
 #define _GDKMM_REGION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -231,6 +230,5 @@ Gdk::Region wrap(GdkRegion* object, bool take_copy = false);
 
 } // namespace Glib
 
-
 #endif /* _GDKMM_REGION_H */
 
diff --git a/libs/gtkmm2/gdk/gdkmm/rgbcmap.cc b/libs/gtkmm2/gdk/gdkmm/rgbcmap.cc
index a3ef2a99d8..84a87d5439 100644
--- a/libs/gtkmm2/gdk/gdkmm/rgbcmap.cc
+++ b/libs/gtkmm2/gdk/gdkmm/rgbcmap.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/rgbcmap.h>
 #include <gdkmm/private/rgbcmap_p.h>
 
diff --git a/libs/gtkmm2/gdk/gdkmm/rgbcmap.h b/libs/gtkmm2/gdk/gdkmm/rgbcmap.h
index a9a72a1366..0f01f1e619 100644
--- a/libs/gtkmm2/gdk/gdkmm/rgbcmap.h
+++ b/libs/gtkmm2/gdk/gdkmm/rgbcmap.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_RGBCMAP_H
 #define _GDKMM_RGBCMAP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
diff --git a/libs/gtkmm2/gdk/gdkmm/screen.cc b/libs/gtkmm2/gdk/gdkmm/screen.cc
index b41daef539..0b64a27a59 100644
--- a/libs/gtkmm2/gdk/gdkmm/screen.cc
+++ b/libs/gtkmm2/gdk/gdkmm/screen.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/screen.h>
 #include <gdkmm/private/screen_p.h>
 
@@ -41,15 +40,13 @@ namespace Gdk
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Screen_signal_size_changed_info =
+const Glib::SignalProxyInfo Screen_signal_size_changed_info =
 {
   "size-changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -96,18 +93,10 @@ void Screen_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->size_changed = &size_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Screen_Class::size_changed_callback(GdkScreen* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -120,19 +109,15 @@ void Screen_Class::size_changed_callback(GdkScreen* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_size_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -145,7 +130,6 @@ void Screen_Class::size_changed_callback(GdkScreen* self)
       (*base->size_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Screen_Class::wrap_new(GObject* object)
@@ -193,140 +177,145 @@ Glib::RefPtr<Colormap> Screen::get_default_colormap()
 {
 
   Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_screen_get_default_colormap(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Colormap> Screen::get_default_colormap() const
 {
-  return const_cast<Screen*>(this)->get_default_colormap();
+
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_screen_get_default_colormap(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Screen::set_default_colormap(const Glib::RefPtr<const Colormap>& colormap)
 {
-gdk_screen_set_default_colormap(gobj(), const_cast<GdkColormap*>(Glib::unwrap<Colormap>(colormap))); 
+  gdk_screen_set_default_colormap(gobj(), const_cast<GdkColormap*>(Glib::unwrap<Colormap>(colormap)));
 }
 
 Glib::RefPtr<Colormap> Screen::get_system_colormap()
 {
 
   Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_screen_get_system_colormap(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Colormap> Screen::get_system_colormap() const
 {
-  return const_cast<Screen*>(this)->get_system_colormap();
+
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_screen_get_system_colormap(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Visual> Screen::get_system_visual()
 {
 
   Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_screen_get_system_visual(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Visual> Screen::get_system_visual() const
 {
-  return const_cast<Screen*>(this)->get_system_visual();
+
+  Glib::RefPtr<const Visual> retvalue = Glib::wrap(gdk_screen_get_system_visual(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Colormap> Screen::get_rgb_colormap()
 {
 
   Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_screen_get_rgb_colormap(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Colormap> Screen::get_rgb_colormap() const
 {
-  return const_cast<Screen*>(this)->get_rgb_colormap();
-}
 
-Glib::RefPtr<Visual> Screen::get_rgb_visual()
-{
+  Glib::RefPtr<const Colormap> retvalue = Glib::wrap(gdk_screen_get_rgb_colormap(const_cast<GdkScreen*>(gobj())));
 
-  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_screen_get_rgb_visual(gobj()));
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
-Glib::RefPtr<const Visual> Screen::get_rgb_visual() const
+Glib::RefPtr<Visual> Screen::get_rgb_visual()
 {
-  return const_cast<Screen*>(this)->get_rgb_visual();
-}
 
-Glib::RefPtr<Colormap> Screen::get_rgba_colormap()
-{
+  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_screen_get_rgb_visual(gobj()));
 
-  Glib::RefPtr<Colormap> retvalue = Glib::wrap(gdk_screen_get_rgba_colormap(gobj()));
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
-Glib::RefPtr<const Colormap> Screen::get_rgba_colormap() const
+Glib::RefPtr<const Visual> Screen::get_rgb_visual() const
 {
-  return const_cast<Screen*>(this)->get_rgba_colormap();
-}
 
-Glib::RefPtr<Visual> Screen::get_rgba_visual()
-{
+  Glib::RefPtr<const Visual> retvalue = Glib::wrap(gdk_screen_get_rgb_visual(const_cast<GdkScreen*>(gobj())));
 
-  Glib::RefPtr<Visual> retvalue = Glib::wrap(gdk_screen_get_rgba_visual(gobj()));
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
-}
-
-Glib::RefPtr<const Visual> Screen::get_rgba_visual() const
-{
-  return const_cast<Screen*>(this)->get_rgba_visual();
 }
 
 Glib::RefPtr<Window> Screen::get_root_window()
 {
 
   Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_screen_get_root_window(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Window> Screen::get_root_window() const
 {
-  return const_cast<Screen*>(this)->get_root_window();
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_screen_get_root_window(const_cast<GdkScreen*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Display> Screen::get_display()
 {
 
   Glib::RefPtr<Display> retvalue = Glib::wrap(gdk_screen_get_display(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Display> Screen::get_display() const
 {
-  return const_cast<Screen*>(this)->get_display();
+
+  Glib::RefPtr<const Display> retvalue = Glib::wrap(gdk_screen_get_display(const_cast<GdkScreen*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 int Screen::get_number() const
@@ -376,7 +365,7 @@ int Screen::get_n_monitors() const
 
 void Screen::get_monitor_geometry(int monitor_num, Rectangle& dest) const
 {
-gdk_screen_get_monitor_geometry(const_cast<GdkScreen*>(gobj()), monitor_num, (dest).gobj()); 
+  gdk_screen_get_monitor_geometry(const_cast<GdkScreen*>(gobj()), monitor_num, (dest).gobj());
 }
 
 int Screen::get_monitor_at_point(int x, int y) const
@@ -391,7 +380,7 @@ int Screen::get_monitor_at_window(const Glib::RefPtr<Window>& window) const
 
 void Screen::broadcast_client_message(GdkEvent* event)
 {
-gdk_screen_broadcast_client_message(gobj(), event); 
+  gdk_screen_broadcast_client_message(gobj(), event);
 }
 
 Glib::RefPtr<Screen> Screen::get_default()
@@ -411,7 +400,6 @@ Glib::SignalProxy0< void > Screen::signal_size_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gdk::Screen::on_size_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -421,10 +409,6 @@ void Gdk::Screen::on_size_changed()
   if(base && base->size_changed)
     (*base->size_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/screen.h b/libs/gtkmm2/gdk/gdkmm/screen.h
index 5cdb4e744a..29ae15d54f 100644
--- a/libs/gtkmm2/gdk/gdkmm/screen.h
+++ b/libs/gtkmm2/gdk/gdkmm/screen.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_SCREEN_H
 #define _GDKMM_SCREEN_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -107,21 +106,21 @@ public:
   /** Gets the default colormap for @a screen .
    * @return The default Gdk::Colormap.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Colormap> get_default_colormap();
   
   /** Gets the default colormap for @a screen .
    * @return The default Gdk::Colormap.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Colormap> get_default_colormap() const;
 
   
   /** Sets the default @a colormap  for @a screen .
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param colormap A Gdk::Colormap.
    */
   void set_default_colormap(const Glib::RefPtr<const Colormap>& colormap);
@@ -129,14 +128,14 @@ public:
   /** Gets the system's default colormap for @a screen 
    * @return The default colormap for @a screen .
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Colormap> get_system_colormap();
   
   /** Gets the system's default colormap for @a screen 
    * @return The default colormap for @a screen .
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Colormap> get_system_colormap() const;
 
@@ -146,7 +145,7 @@ public:
    * The return value should not be freed.
    * @return The system visual
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Visual> get_system_visual();
   
@@ -155,7 +154,7 @@ public:
    * The return value should not be freed.
    * @return The system visual
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Visual> get_system_visual() const;
 
@@ -167,7 +166,7 @@ public:
    * call this function.
    * @return The preferred colormap
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Colormap> get_rgb_colormap();
   
@@ -178,7 +177,7 @@ public:
    * call this function.
    * @return The preferred colormap
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Colormap> get_rgb_colormap() const;
 
@@ -191,7 +190,7 @@ public:
    * drawables with any visual.
    * @return The Gdk::Visual chosen by GdkRGB.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Visual> get_rgb_visual();
   
@@ -203,74 +202,22 @@ public:
    * drawables with any visual.
    * @return The Gdk::Visual chosen by GdkRGB.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Visual> get_rgb_visual() const;
 
   
-  /** Gets a colormap to use for creating windows or pixmaps with an
-   * alpha channel. The windowing system on which GTK+ is running
-   * may not support this capability, in which case <tt>0</tt> will
-   * be returned. Even if a non-<tt>0</tt> value is returned, its
-   * possible that the window's alpha channel won't be honored
-   * when displaying the window on the screen: in particular, for
-   * X an appropriate windowing manager and compositing manager
-   * must be running to provide appropriate display.
-   * @return A colormap to use for windows with an alpha channel
-   * or <tt>0</tt> if the capability is not available.
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<Colormap> get_rgba_colormap();
-  
-  /** Gets a colormap to use for creating windows or pixmaps with an
-   * alpha channel. The windowing system on which GTK+ is running
-   * may not support this capability, in which case <tt>0</tt> will
-   * be returned. Even if a non-<tt>0</tt> value is returned, its
-   * possible that the window's alpha channel won't be honored
-   * when displaying the window on the screen: in particular, for
-   * X an appropriate windowing manager and compositing manager
-   * must be running to provide appropriate display.
-   * @return A colormap to use for windows with an alpha channel
-   * or <tt>0</tt> if the capability is not available.
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<const Colormap> get_rgba_colormap() const;
-
-  
-  /** Gets a visual to use for creating windows or pixmaps with an
-   * alpha channel. See the docs for get_rgba_colormap()
-   * for caveats.
-   * @return A visual to use for windows with an alpha channel
-   * or <tt>0</tt> if the capability is not available.
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<Visual> get_rgba_visual();
-  
-  /** Gets a visual to use for creating windows or pixmaps with an
-   * alpha channel. See the docs for get_rgba_colormap()
-   * for caveats.
-   * @return A visual to use for windows with an alpha channel
-   * or <tt>0</tt> if the capability is not available.
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<const Visual> get_rgba_visual() const;
-
-  
   /** Gets the root window of @a screen .
    * @return The root window
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Window> get_root_window();
   
   /** Gets the root window of @a screen .
    * @return The root window
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Window> get_root_window() const;
 
@@ -278,14 +225,14 @@ public:
   /** Gets the display to which the @a screen  belongs.
    * @return The display to which @a screen  belongs
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Display> get_display();
   
   /** Gets the display to which the @a screen  belongs.
    * @return The display to which @a screen  belongs
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Display> get_display() const;
 
@@ -294,37 +241,37 @@ public:
    * to which it belongs. (See get_display())
    * @return The index
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_number() const;
   
   /** Gets the width of @a screen  in pixels
    * @return The width of @a screen  in pixels.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_width() const;
   
   /** Gets the height of @a screen  in pixels
    * @return The height of @a screen  in pixels.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_height() const;
   
   /** Gets the width of @a screen  in millimeters. 
    * Note that on some X servers this value will not be correct.
-   * @return The width of @a screen  in millimeters.
+   * @return The width of @a screen  in pixels.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_width_mm() const;
   
   /** Returns the height of @a screen  in millimeters. 
    * Note that on some X servers this value will not be correct.
-   * @return The heigth of @a screen  in millimeters.
+   * @return The heigth of @a screen  in pixels.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_height_mm() const;
 
@@ -333,24 +280,26 @@ public:
    * A visual describes a hardware image data format.
    * For example, a visual might support 24-bit color, or 8-bit color,
    * and might expect pixels to be in a certain format.
-   *  @a newin2p2 
    * @return A list of visuals.
+   * 
+   * Since: 2.2.
    */
   Glib::ListHandle< Glib::RefPtr<Visual> > list_visuals();
   
   /** Obtains a list of all toplevel windows known to GDK on the screen @a screen .
    * A toplevel window is a child of the root window (see
    * gdk_get_default_root_window()).
-   *  @a newin2p2 
    * @return List of toplevel windows.
+   * 
+   * Since: 2.2.
    */
   Glib::ListHandle< Glib::RefPtr<Window> > get_toplevel_windows();
   
   /** Determines the name to pass to Gdk::Display::open() to get
    * a Gdk::Display with this screen as the default screen.
-   * 
-   *  @a newin2p2 
    * @return The name.
+   * 
+   * Since: 2.2.
    */
   Glib::ustring make_display_name();
 
@@ -358,17 +307,17 @@ public:
   /** Returns the number of monitors which @a screen  consists of.
    * @return Number of monitors which @a screen  consists of.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_n_monitors() const;
   
   /** Retrieves the Gdk::Rectangle representing the size and position of 
-   * the individual monitor within the entire screen area.
+   * the individual monitor within the the entire screen area.
    * 
    * Note that the size of the entire screen area can be retrieved via 
    * get_width() and get_height().
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param monitor_num The monitor number.
    * @param dest A Gdk::Rectangle to be filled with the monitor geometry.
    */
@@ -380,7 +329,7 @@ public:
    * @return The monitor number in which the point ( @a x , @a y ) lies, or
    * a monitor close to ( @a x , @a y ) if the point is not in any monitor.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_monitor_at_point(int x, int y) const;
   
@@ -392,7 +341,7 @@ public:
    * the number of the monitor in which the largest area of the 
    * bounding rectangle of @a window  resides.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_monitor_at_window(const Glib::RefPtr<Window>& window) const;
 
@@ -409,7 +358,7 @@ public:
    * GDK_WIN32_CLIENT_MESSAGE to all top-level windows. The amount of
    * data is limited to one long, i.e. four bytes.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param event The Gdk::Event.
    */
   void broadcast_client_message(GdkEvent* event);
@@ -419,7 +368,7 @@ public:
    * Gdk::Display::get_default()).
    * @return A Gdk::Screen, or <tt>0</tt> if there is no default display.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   static Glib::RefPtr<Screen> get_default();
 
@@ -427,15 +376,6 @@ public:
   bool get_setting(const Glib::ustring& name, ValueType& value) const;
   
 
-  /** The size_changed signal is emitted when the pixel width or 
-   * height of a screen changes.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %size_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_size_changed();
 
 
@@ -443,18 +383,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_size_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/types.cc b/libs/gtkmm2/gdk/gdkmm/types.cc
index df14515999..e15170aadb 100644
--- a/libs/gtkmm2/gdk/gdkmm/types.cc
+++ b/libs/gtkmm2/gdk/gdkmm/types.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/types.h>
 #include <gdkmm/private/types_p.h>
 
diff --git a/libs/gtkmm2/gdk/gdkmm/types.h b/libs/gtkmm2/gdk/gdkmm/types.h
index 60dd486794..1f0c0fafd4 100644
--- a/libs/gtkmm2/gdk/gdkmm/types.h
+++ b/libs/gtkmm2/gdk/gdkmm/types.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_TYPES_H
 #define _GDKMM_TYPES_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -329,7 +328,7 @@ inline bool operator==(const Point& lhs, const Point& rhs)
 inline bool operator!=(const Point& lhs, const Point& rhs)
   { return !lhs.equal(rhs); }
 
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
 struct AtomStringTraits
 {
   typedef std::string CppType;
@@ -349,7 +348,6 @@ struct AtomStringTraits
 // we don't want it to look like we're calling a template trait, but
 // a utility function. -Bryan
 typedef AtomStringTraits AtomString;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
 
 typedef Glib::ArrayHandle<std::string,AtomStringTraits> ArrayHandle_AtomString;
 
diff --git a/libs/gtkmm2/gdk/gdkmm/visual.cc b/libs/gtkmm2/gdk/gdkmm/visual.cc
index 4f77645a88..4d4e84774c 100644
--- a/libs/gtkmm2/gdk/gdkmm/visual.cc
+++ b/libs/gtkmm2/gdk/gdkmm/visual.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/visual.h>
 #include <gdkmm/private/visual_p.h>
 
@@ -90,19 +89,8 @@ void Visual_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Visual_Class::wrap_new(GObject* object)
 {
@@ -162,7 +150,6 @@ Glib::RefPtr<Visual> Visual::get_system()
   return retvalue;
 }
 
-
 Glib::RefPtr<Visual> Visual::get_best()
 {
 
@@ -173,7 +160,6 @@ Glib::RefPtr<Visual> Visual::get_best()
   return retvalue;
 }
 
-
 Glib::RefPtr<Visual> Visual::get_best(int depth)
 {
 
@@ -184,7 +170,6 @@ Glib::RefPtr<Visual> Visual::get_best(int depth)
   return retvalue;
 }
 
-
 Glib::RefPtr<Visual> Visual::get_best(VisualType visual_type)
 {
 
@@ -195,7 +180,6 @@ Glib::RefPtr<Visual> Visual::get_best(VisualType visual_type)
   return retvalue;
 }
 
-
 Glib::RefPtr<Visual> Visual::get_best(int depth, VisualType visual_type)
 {
 
@@ -206,40 +190,35 @@ Glib::RefPtr<Visual> Visual::get_best(int depth, VisualType visual_type)
   return retvalue;
 }
 
-
 int Visual::get_best_depth()
 {
   return gdk_visual_get_best_depth();
 }
 
-
 VisualType Visual::get_best_type()
 {
   return ((VisualType)(gdk_visual_get_best_type()));
 }
 
-
 Glib::RefPtr<Screen> Visual::get_screen()
 {
 
   Glib::RefPtr<Screen> retvalue = Glib::wrap(gdk_visual_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Screen> Visual::get_screen() const
 {
-  return const_cast<Visual*>(this)->get_screen();
-}
-
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+  Glib::RefPtr<const Screen> retvalue = Glib::wrap(gdk_visual_get_screen(const_cast<GdkVisual*>(gobj())));
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
 
 
 } // namespace Gdk
diff --git a/libs/gtkmm2/gdk/gdkmm/visual.h b/libs/gtkmm2/gdk/gdkmm/visual.h
index b170b4ce15..66f3cd5807 100644
--- a/libs/gtkmm2/gdk/gdkmm/visual.h
+++ b/libs/gtkmm2/gdk/gdkmm/visual.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_VISUAL_H
 #define _GDKMM_VISUAL_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -211,14 +210,14 @@ public:
   /** Gets the screen to which this visual belongs
    * @return The screen to which this visual belongs.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Screen> get_screen();
    
   /** Gets the screen to which this visual belongs
    * @return The screen to which this visual belongs.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Screen> get_screen() const;
 
@@ -227,17 +226,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gdk/gdkmm/window.cc b/libs/gtkmm2/gdk/gdkmm/window.cc
index 90c72d1dc7..9419c5b01b 100644
--- a/libs/gtkmm2/gdk/gdkmm/window.cc
+++ b/libs/gtkmm2/gdk/gdkmm/window.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gdkmm/window.h>
 #include <gdkmm/private/window_p.h>
 
@@ -201,19 +200,8 @@ void Window_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Window_Class::wrap_new(GObject* object)
 {
@@ -267,122 +255,117 @@ WindowType Window::get_window_type() const
 
 void Window::show()
 {
-gdk_window_show(gobj()); 
+  gdk_window_show(gobj());
 }
 
 void Window::hide()
 {
-gdk_window_hide(gobj()); 
+  gdk_window_hide(gobj());
 }
 
 void Window::withdraw()
 {
-gdk_window_withdraw(gobj()); 
+  gdk_window_withdraw(gobj());
 }
 
 void Window::show_unraised()
 {
-gdk_window_show_unraised(gobj()); 
+  gdk_window_show_unraised(gobj());
 }
 
 void Window::move(int x, int y)
 {
-gdk_window_move(gobj(), x, y); 
+  gdk_window_move(gobj(), x, y);
 }
 
 void Window::resize(int width, int height)
 {
-gdk_window_resize(gobj(), width, height); 
+  gdk_window_resize(gobj(), width, height);
 }
 
 void Window::move_resize(int x, int y, int width, int height)
 {
-gdk_window_move_resize(gobj(), x, y, width, height); 
+  gdk_window_move_resize(gobj(), x, y, width, height);
 }
 
 void Window::reparent(const Glib::RefPtr<Window>& new_parent, int x, int y)
 {
-gdk_window_reparent(gobj(), Glib::unwrap(new_parent), x, y); 
+  gdk_window_reparent(gobj(), Glib::unwrap(new_parent), x, y);
 }
 
 void Window::clear()
 {
-gdk_window_clear(gobj()); 
+  gdk_window_clear(gobj());
 }
 
 void Window::clear_area(int x, int y, int width, int height)
 {
-gdk_window_clear_area(gobj(), x, y, width, height); 
+  gdk_window_clear_area(gobj(), x, y, width, height);
 }
 
 void Window::clear_area_e(int x, int y, int width, int height)
 {
-gdk_window_clear_area_e(gobj(), x, y, width, height); 
+  gdk_window_clear_area_e(gobj(), x, y, width, height);
 }
 
 void Window::raise()
 {
-gdk_window_raise(gobj()); 
+  gdk_window_raise(gobj());
 }
 
 void Window::lower()
 {
-gdk_window_lower(gobj()); 
+  gdk_window_lower(gobj());
 }
 
 void Window::focus(guint32 timestamp)
 {
-gdk_window_focus(gobj(), timestamp); 
+  gdk_window_focus(gobj(), timestamp);
 }
 
 void Window::set_user_data(gpointer user_data)
 {
-gdk_window_set_user_data(gobj(), user_data); 
+  gdk_window_set_user_data(gobj(), user_data);
 }
 
 void Window::set_override_redirect(bool override_redirect)
 {
-gdk_window_set_override_redirect(gobj(), static_cast<int>(override_redirect)); 
+  gdk_window_set_override_redirect(gobj(), static_cast<int>(override_redirect));
 }
 
 void Window::add_filter(GdkFilterFunc function, gpointer data)
 {
-gdk_window_add_filter(gobj(), function, data); 
+  gdk_window_add_filter(gobj(), function, data);
 }
 
 void Window::remove_filter(GdkFilterFunc function, gpointer data)
 {
-gdk_window_remove_filter(gobj(), function, data); 
+  gdk_window_remove_filter(gobj(), function, data);
 }
 
 void Window::scroll(int dx, int dy)
 {
-gdk_window_scroll(gobj(), dx, dy); 
-}
-
-void Window::move_region(const Region& region, int dx, int dy)
-{
-gdk_window_move_region(gobj(), const_cast<GdkRegion*>((region).gobj()), dx, dy); 
+  gdk_window_scroll(gobj(), dx, dy);
 }
 
 void Window::shape_combine_mask(const Glib::RefPtr<Bitmap>& mask, int x, int y)
 {
-gdk_window_shape_combine_mask(gobj(), Glib::unwrap(mask), x, y); 
+  gdk_window_shape_combine_mask(gobj(), Glib::unwrap(mask), x, y);
 }
 
 void Window::shape_combine_region(const Region& shape_region, int offset_x, int offset_y)
 {
-gdk_window_shape_combine_region(gobj(), const_cast<GdkRegion*>((shape_region).gobj()), offset_x, offset_y); 
+  gdk_window_shape_combine_region(gobj(), const_cast<GdkRegion*>((shape_region).gobj()), offset_x, offset_y);
 }
 
 void Window::set_child_shapes()
 {
-gdk_window_set_child_shapes(gobj()); 
+  gdk_window_set_child_shapes(gobj());
 }
 
 void Window::merge_child_shapes()
 {
-gdk_window_merge_child_shapes(gobj()); 
+  gdk_window_merge_child_shapes(gobj());
 }
 
 bool Window::is_visible() const
@@ -407,83 +390,82 @@ bool Window::set_static_gravities(bool use_static)
 
 void Window::set_type_hint(WindowTypeHint hint)
 {
-gdk_window_set_type_hint(gobj(), ((GdkWindowTypeHint)(hint))); 
+  gdk_window_set_type_hint(gobj(), ((GdkWindowTypeHint)(hint)));
 }
 
 void Window::set_modal_hint(bool modal)
 {
-gdk_window_set_modal_hint(gobj(), static_cast<int>(modal)); 
+  gdk_window_set_modal_hint(gobj(), static_cast<int>(modal));
 }
 
 void Window::set_geometry_hints(const Geometry& geometry, WindowHints geom_mask)
 {
-gdk_window_set_geometry_hints(gobj(), const_cast<GdkGeometry*>(&(geometry)), ((GdkWindowHints)(geom_mask))); 
+  gdk_window_set_geometry_hints(gobj(), const_cast<GdkGeometry*>(&(geometry)), ((GdkWindowHints)(geom_mask)));
 }
 
 void Window::set_sm_client_id(const Glib::ustring& sm_client_id)
 {
-gdk_set_sm_client_id(sm_client_id.c_str());
+  gdk_set_sm_client_id(sm_client_id.c_str());
 }
 
-
 void Window::begin_paint_rect(Rectangle& rectangle)
 {
-gdk_window_begin_paint_rect(gobj(), (rectangle).gobj()); 
+  gdk_window_begin_paint_rect(gobj(), (rectangle).gobj());
 }
 
 void Window::begin_paint_region(const Region& region)
 {
-gdk_window_begin_paint_region(gobj(), const_cast<GdkRegion*>((region).gobj())); 
+  gdk_window_begin_paint_region(gobj(), const_cast<GdkRegion*>((region).gobj()));
 }
 
 void Window::end_paint()
 {
-gdk_window_end_paint(gobj()); 
+  gdk_window_end_paint(gobj());
 }
 
 void Window::set_title(const Glib::ustring& title)
 {
-gdk_window_set_title(gobj(), title.c_str()); 
+  gdk_window_set_title(gobj(), title.c_str());
 }
 
 void Window::set_role(const Glib::ustring& role)
 {
-gdk_window_set_role(gobj(), role.c_str()); 
+  gdk_window_set_role(gobj(), role.c_str());
 }
 
 void Window::set_transient_for(const Glib::RefPtr<Window>& parent)
 {
-gdk_window_set_transient_for(gobj(), Glib::unwrap(parent)); 
+  gdk_window_set_transient_for(gobj(), Glib::unwrap(parent));
 }
 
 void Window::set_background(const Color& color)
 {
-gdk_window_set_background(gobj(), (color).gobj()); 
+  gdk_window_set_background(gobj(), (color).gobj());
 }
 
 void Window::set_back_pixmap(const Glib::RefPtr<Pixmap>& pixmap, bool parent_relative)
 {
-gdk_window_set_back_pixmap(gobj(), Glib::unwrap(pixmap), static_cast<int>(parent_relative)); 
+  gdk_window_set_back_pixmap(gobj(), Glib::unwrap(pixmap), static_cast<int>(parent_relative));
 }
 
 void Window::set_cursor(const Cursor& cursor)
 {
-gdk_window_set_cursor(gobj(), const_cast<GdkCursor*>((cursor).gobj())); 
+  gdk_window_set_cursor(gobj(), (cursor).gobj_copy());
 }
 
 void Window::get_user_data(gpointer* data)
 {
-gdk_window_get_user_data(gobj(), data); 
+  gdk_window_get_user_data(gobj(), data);
 }
 
 void Window::get_geometry(int& x, int& y, int& width, int& height, int& depth) const
 {
-gdk_window_get_geometry(const_cast<GdkWindow*>(gobj()), &x, &y, &width, &height, &depth); 
+  gdk_window_get_geometry(const_cast<GdkWindow*>(gobj()), &x, &y, &width, &height, &depth);
 }
 
 void Window::get_position(int& x, int& y) const
 {
-gdk_window_get_position(const_cast<GdkWindow*>(gobj()), &x, &y); 
+  gdk_window_get_position(const_cast<GdkWindow*>(gobj()), &x, &y);
 }
 
 int Window::get_origin(int& x, int& y) const
@@ -493,52 +475,62 @@ int Window::get_origin(int& x, int& y) const
 
 void Window::get_root_origin(int& x, int& y) const
 {
-gdk_window_get_root_origin(const_cast<GdkWindow*>(gobj()), &x, &y); 
+  gdk_window_get_root_origin(const_cast<GdkWindow*>(gobj()), &x, &y);
 }
 
 void Window::get_frame_extents(Rectangle& rect)
 {
-gdk_window_get_frame_extents(gobj(), (rect).gobj()); 
+  gdk_window_get_frame_extents(gobj(), (rect).gobj());
 }
 
 Glib::RefPtr<Window> Window::get_pointer(int& x, int& y, ModifierType& mask)
 {
 
   Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_pointer(gobj(), &x, &y, ((GdkModifierType*) &(mask)))));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Window> Window::get_parent()
 {
 
   Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_parent(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Window> Window::get_parent() const
 {
-  return const_cast<Window*>(this)->get_parent();
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_parent(const_cast<GdkWindow*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Window> Window::get_toplevel()
 {
 
   Glib::RefPtr<Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_toplevel(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Window> Window::get_toplevel() const
 {
-  return const_cast<Window*>(this)->get_toplevel();
+
+  Glib::RefPtr<const Window> retvalue = Glib::wrap((GdkWindowObject*)(gdk_window_get_toplevel(const_cast<GdkWindow*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::ListHandle< Glib::RefPtr<Window> > Window::get_children()
@@ -558,27 +550,27 @@ EventMask Window::get_events() const
 
 void Window::set_events(EventMask event_mask)
 {
-gdk_window_set_events(gobj(), ((GdkEventMask)(event_mask))); 
+  gdk_window_set_events(gobj(), ((GdkEventMask)(event_mask)));
 }
 
 void Window::set_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& pixbufs)
 {
-gdk_window_set_icon_list(gobj(), pixbufs.data()); 
+  gdk_window_set_icon_list(gobj(), pixbufs.data());
 }
 
 void Window::set_icon(const Glib::RefPtr<Window>& icon_window, const Glib::RefPtr<Pixmap>& pixmap, const Glib::RefPtr<Bitmap>& mask)
 {
-gdk_window_set_icon(gobj(), Glib::unwrap(icon_window), Glib::unwrap(pixmap), Glib::unwrap(mask)); 
+  gdk_window_set_icon(gobj(), Glib::unwrap(icon_window), Glib::unwrap(pixmap), Glib::unwrap(mask));
 }
 
 void Window::set_icon_name(const Glib::ustring& name)
 {
-gdk_window_set_icon_name(gobj(), name.c_str()); 
+  gdk_window_set_icon_name(gobj(), name.c_str());
 }
 
 void Window::set_group(const Glib::RefPtr<Window>& leader)
 {
-gdk_window_set_group(gobj(), Glib::unwrap(leader)); 
+  gdk_window_set_group(gobj(), Glib::unwrap(leader));
 }
 
 Glib::RefPtr<Window> Window::get_group()
@@ -588,12 +580,12 @@ Glib::RefPtr<Window> Window::get_group()
 
 Glib::RefPtr<const Window> Window::get_group() const
 {
-  return const_cast<Window*>(this)->get_group();
+  return Glib::wrap((GdkWindowObject*)(gdk_window_get_group(const_cast<GdkWindow*>(gobj()))));
 }
 
 void Window::set_decorations(WMDecoration decorations)
 {
-gdk_window_set_decorations(gobj(), ((GdkWMDecoration)(decorations))); 
+  gdk_window_set_decorations(gobj(), ((GdkWMDecoration)(decorations)));
 }
 
 bool Window::get_decorations(WMDecoration& decorations) const
@@ -603,7 +595,7 @@ bool Window::get_decorations(WMDecoration& decorations) const
 
 void Window::set_functions(WMFunction functions)
 {
-gdk_window_set_functions(gobj(), ((GdkWMFunction)(functions))); 
+  gdk_window_set_functions(gobj(), ((GdkWMFunction)(functions)));
 }
 
 Glib::ListHandle< Glib::RefPtr<Window> > Window::get_toplevels()
@@ -611,60 +603,59 @@ Glib::ListHandle< Glib::RefPtr<Window> > Window::get_toplevels()
   return Glib::ListHandle< Glib::RefPtr<Window> >(gdk_window_get_toplevels(), Glib::OWNERSHIP_SHALLOW);
 }
 
-
 void Window::iconify()
 {
-gdk_window_iconify(gobj()); 
+  gdk_window_iconify(gobj());
 }
 
 void Window::deiconify()
 {
-gdk_window_deiconify(gobj()); 
+  gdk_window_deiconify(gobj());
 }
 
 void Window::stick()
 {
-gdk_window_stick(gobj()); 
+  gdk_window_stick(gobj());
 }
 
 void Window::unstick()
 {
-gdk_window_unstick(gobj()); 
+  gdk_window_unstick(gobj());
 }
 
 void Window::maximize()
 {
-gdk_window_maximize(gobj()); 
+  gdk_window_maximize(gobj());
 }
 
 void Window::unmaximize()
 {
-gdk_window_unmaximize(gobj()); 
+  gdk_window_unmaximize(gobj());
 }
 
 void Window::register_dnd()
 {
-gdk_window_register_dnd(gobj()); 
+  gdk_window_register_dnd(gobj());
 }
 
 void Window::begin_resize_drag(WindowEdge edge, int button, int root_x, int root_y, guint32 timestamp)
 {
-gdk_window_begin_resize_drag(gobj(), ((GdkWindowEdge)(edge)), button, root_x, root_y, timestamp); 
+  gdk_window_begin_resize_drag(gobj(), ((GdkWindowEdge)(edge)), button, root_x, root_y, timestamp);
 }
 
 void Window::begin_move_drag(int button, int root_x, int root_y, guint32 timestamp)
 {
-gdk_window_begin_move_drag(gobj(), button, root_x, root_y, timestamp); 
+  gdk_window_begin_move_drag(gobj(), button, root_x, root_y, timestamp);
 }
 
 void Window::invalidate_rect(const Rectangle& rect, bool invalidate_children)
 {
-gdk_window_invalidate_rect(gobj(), const_cast<GdkRectangle*>(rect.gobj()), static_cast<int>(invalidate_children)); 
+  gdk_window_invalidate_rect(gobj(), const_cast<GdkRectangle*>(rect.gobj()), static_cast<int>(invalidate_children));
 }
 
 void Window::invalidate_region(const Region& region, bool invalidate_children)
 {
-gdk_window_invalidate_region(gobj(), const_cast<GdkRegion*>((region).gobj()), static_cast<int>(invalidate_children)); 
+  gdk_window_invalidate_region(gobj(), const_cast<GdkRegion*>((region).gobj()), static_cast<int>(invalidate_children));
 }
 
 Region Window::get_update_area()
@@ -674,83 +665,74 @@ Region Window::get_update_area()
 
 void Window::freeze_updates()
 {
-gdk_window_freeze_updates(gobj()); 
+  gdk_window_freeze_updates(gobj());
 }
 
 void Window::thaw_updates()
 {
-gdk_window_thaw_updates(gobj()); 
+  gdk_window_thaw_updates(gobj());
 }
 
 void Window::process_all_updates()
 {
-gdk_window_process_all_updates();
+  gdk_window_process_all_updates();
 }
 
-
 void Window::process_updates(bool update_children)
 {
-gdk_window_process_updates(gobj(), static_cast<int>(update_children)); 
+  gdk_window_process_updates(gobj(), static_cast<int>(update_children));
 }
 
 void Window::set_debug_updates(bool setting)
 {
-gdk_window_set_debug_updates(static_cast<int>(setting));
+  gdk_window_set_debug_updates(static_cast<int>(setting));
 }
 
-
 void Window::constrain_size(const Geometry& geometry, guint flags, int width, int height, int& new_width, int& new_height)
 {
-gdk_window_constrain_size(const_cast<GdkGeometry*>(&(geometry)), flags, width, height, &new_width, &new_height);
+  gdk_window_constrain_size(const_cast<GdkGeometry*>(&(geometry)), flags, width, height, &new_width, &new_height);
 }
 
-
 void Window::enable_synchronized_configure()
 {
-gdk_window_enable_synchronized_configure(gobj()); 
+  gdk_window_enable_synchronized_configure(gobj());
 }
 
 void Window::configure_finished()
 {
-gdk_window_configure_finished(gobj()); 
+  gdk_window_configure_finished(gobj());
 }
 
 void Window::set_skip_taskbar_hint(bool skips_taskbar)
 {
-gdk_window_set_skip_taskbar_hint(gobj(), static_cast<int>(skips_taskbar)); 
+  gdk_window_set_skip_taskbar_hint(gobj(), static_cast<int>(skips_taskbar));
 }
 
 void Window::set_skip_pager_hint(bool skips_pager)
 {
-gdk_window_set_skip_pager_hint(gobj(), static_cast<int>(skips_pager)); 
-}
-
-void Window::set_urgency_hint(bool urgent)
-{
-gdk_window_set_urgency_hint(gobj(), static_cast<int>(urgent)); 
+  gdk_window_set_skip_pager_hint(gobj(), static_cast<int>(skips_pager));
 }
 
 void Window::fullscreen()
 {
-gdk_window_fullscreen(gobj()); 
+  gdk_window_fullscreen(gobj());
 }
 
 void Window::unfullscreen()
 {
-gdk_window_unfullscreen(gobj()); 
+  gdk_window_unfullscreen(gobj());
 }
 
 GrabStatus Window::pointer_grab(bool owner_events, EventMask event_mask, const Glib::RefPtr<const Window>& confine_to, const Cursor& cursor, guint32 time_)
 {
-  return ((GrabStatus)(gdk_pointer_grab(gobj(), static_cast<int>(owner_events), ((GdkEventMask)(event_mask)), const_cast<GdkWindow*>(Glib::unwrap<Gdk::Window>(confine_to)), const_cast<GdkCursor*>((cursor).gobj()), time_)));
+  return ((GrabStatus)(gdk_pointer_grab(gobj(), static_cast<int>(owner_events), ((GdkEventMask)(event_mask)), const_cast<GdkWindow*>(Glib::unwrap<Gdk::Window>(confine_to)), (cursor).gobj_copy(), time_)));
 }
 
 void Window::pointer_ungrab(guint32 timestamp)
 {
-gdk_pointer_ungrab(timestamp);
+  gdk_pointer_ungrab(timestamp);
 }
 
-
 GrabStatus Window::keyboard_grab(bool owner_events, guint32 timestamp)
 {
   return ((GrabStatus)(gdk_keyboard_grab(gobj(), static_cast<int>(owner_events), timestamp)));
@@ -758,38 +740,30 @@ GrabStatus Window::keyboard_grab(bool owner_events, guint32 timestamp)
 
 void Window::keyboard_ungrab(guint32 timestamp)
 {
-gdk_keyboard_ungrab(timestamp);
+  gdk_keyboard_ungrab(timestamp);
 }
 
-
 void Window::set_keep_above(bool setting)
 {
-gdk_window_set_keep_above(gobj(), static_cast<int>(setting)); 
+  gdk_window_set_keep_above(gobj(), static_cast<int>(setting));
 }
 
 void Window::set_keep_below(bool setting)
 {
-gdk_window_set_keep_below(gobj(), static_cast<int>(setting)); 
+  gdk_window_set_keep_below(gobj(), static_cast<int>(setting));
 }
 
 void Window::set_accept_focus(bool accept_focus)
 {
-gdk_window_set_accept_focus(gobj(), static_cast<int>(accept_focus)); 
+  gdk_window_set_accept_focus(gobj(), static_cast<int>(accept_focus));
 }
 
 void Window::set_focus_on_map(bool focus_on_map)
 {
-gdk_window_set_focus_on_map(gobj(), static_cast<int>(focus_on_map)); 
+  gdk_window_set_focus_on_map(gobj(), static_cast<int>(focus_on_map));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gdk
 
 
diff --git a/libs/gtkmm2/gdk/gdkmm/window.h b/libs/gtkmm2/gdk/gdkmm/window.h
index 40acfafa32..7b8d9c614d 100644
--- a/libs/gtkmm2/gdk/gdkmm/window.h
+++ b/libs/gtkmm2/gdk/gdkmm/window.h
@@ -3,7 +3,6 @@
 #ifndef _GDKMM_WINDOW_H
 #define _GDKMM_WINDOW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -868,8 +867,9 @@ public:
    */
   void lower();
   
-  /** Sets keyboard focus to @a window . In most cases, gtk_window_present() 
-   * should be used on a Gtk::Window, rather than calling this function.
+  /** Sets keyboard focus to @a window . If @a window  is not onscreen this
+   * will not work. In most cases, gtk_window_present() should be used on
+   * a Gtk::Window, rather than calling this function.
    * @param timestamp Timestamp of the event triggering the window focus.
    */
   void focus(guint32 timestamp);
@@ -929,20 +929,6 @@ public:
    */
   void scroll(int dx, int dy);
   
-  /** Move the part of @a window  indicated by @a region  by @a dy  pixels in the Y 
-   * direction and @a dx  pixels in the X direction. The portions of @a region  
-   * that not covered by the new position of @a region  are invalidated.
-   * 
-   * Child windows are not moved.
-   * 
-   * @newin2p8
-   * @param region The Gdk::Region to move.
-   * @param dx Amount to move in the X direction.
-   * @param dy Amount to move in the Y direction.
-   */
-  void move_region(const Region& region, int dx, int dy);
-
-  
   /** Applies a shape mask to @a window . Pixels in @a window  corresponding to
    * set bits in the @a mask  will be visible; pixels in @a window 
    * corresponding to unset bits in the @a mask  will be transparent. This
@@ -1050,7 +1036,7 @@ public:
    * way.
    * 
    * You should only use this on windows for which you have
-   * previously called gdk_window_set_transient_for()
+   * previously called #gdk_window_set_transient_for()
    * @param modal <tt>true</tt> if the window is modal, <tt>false</tt> otherwise.
    */
   void set_modal_hint(bool modal = true);
@@ -1068,7 +1054,7 @@ public:
    * gdk_window_move_resize().
    * 
    * Note that on X11, this effect has no effect on windows
-   * of type Gdk::WINDOW_TEMP or windows where override redirect
+   * of type GDK_WINDOW_TEMP or windows where override_redirect
    * has been turned on via gdk_window_set_override_redirect()
    * since these windows are not resizable by the user.
    * 
@@ -1224,8 +1210,7 @@ public:
    * @param parent_relative Whether the tiling origin is at the origin of @a window 's parent.
    */
   void set_back_pixmap(const Glib::RefPtr<Pixmap>&pixmap, bool parent_relative);
-
- 
+  
   /** Sets the mouse pointer for a Gdk::Window. 
    * To make the cursor invisible, use gdk_cursor_new_from_pixmap() to create
    * a cursor with no pixels in it.
@@ -1296,7 +1281,7 @@ public:
    * @return Not meaningful, ignore.
    */
   int get_origin(int& x, int& y) const;
-  
+  //_WRAP_METHOD(bool get_deskrelative_origin(int& x, int& y), gdk_window_get_deskrelative_origin)
   
   /** Obtains the top-left corner of the window manager frame in root
    * window coordinates.
@@ -1443,14 +1428,14 @@ public:
   /** Returns the group leader window for @a window . See gdk_window_set_group().
    * @return The group leader window for @a window 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<Window> get_group();
   
   /** Returns the group leader window for @a window . See gdk_window_set_group().
    * @return The group leader window for @a window 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const Window> get_group() const;
 
@@ -1570,8 +1555,9 @@ public:
   /** Begins a window resize operation (for a toplevel window).
    * You might use this function to implement a "window resize grip," for
    * example; in fact Gtk::Statusbar uses it. The function works best
-   * with window managers that support the Extended Window Manager Hints, but has a 
-   * fallback implementation for other window managers.
+   * with window managers that support the Extended Window Manager Hints spec
+   * (see http://www.freedesktop.org), but has a fallback implementation
+   * for other window managers.
    * @param edge The edge or corner from which the drag is started.
    * @param button The button being used to drag.
    * @param root_x Root window X coordinate of mouse click that began the drag.
@@ -1583,8 +1569,8 @@ public:
   /** Begins a window move operation (for a toplevel window).  You might
    * use this function to implement a "window move grip," for
    * example. The function works best with window managers that support
-   * the Extended 
-   * Window Manager Hints, but has a fallback implementation for
+   * the Extended Window Manager Hints spec (see
+   * http://www.freedesktop.org), but has a fallback implementation for
    * other window managers.
    * @param button The button being used to drag.
    * @param root_x Root window X coordinate of mouse click that began the drag.
@@ -1714,7 +1700,7 @@ public:
    * On X, calling this function makes @a window  participate in the
    * _NET_WM_SYNC_REQUEST window manager protocol.
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void enable_synchronized_configure();
   
@@ -1724,10 +1710,10 @@ public:
    * application. GTK+ applications will automatically call this
    * function when appropriate.
    * 
-   * This function can only be called if gdk_window_enable_synchronized_configure()
+   * This function can only be called if gdk_window_use_configure()
    * was called previously.
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void configure_finished();
 
@@ -1735,11 +1721,11 @@ public:
   /** Toggles whether a window should appear in a task list or window
    * list. If a window's semantic type as specified with
    * gdk_window_set_type_hint() already fully describes the window, this
-   * function should <em>not</em> be called in addition, 
-   * instead you should allow the window to be treated according to 
-   * standard policy for its semantic type.
+   * function should NOT be called in addition, instead you should allow
+   * the window to be treated according to standard policy for its
+   * semantic type.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param skips_taskbar <tt>true</tt> to skip the taskbar.
    */
   void set_skip_taskbar_hint(bool skips_taskbar = true);
@@ -1748,26 +1734,16 @@ public:
    * switcher, or other desktop utility program that displays a small
    * thumbnail representation of the windows on the desktop). If a
    * window's semantic type as specified with gdk_window_set_type_hint()
-   * already fully describes the window, this function should 
-   * <em>not</em> be called in addition, instead you should 
-   * allow the window to be treated according to standard policy for 
-   * its semantic type.
+   * already fully describes the window, this function should NOT be
+   * called in addition, instead you should allow the window to be
+   * treated according to standard policy for its semantic type.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param skips_pager <tt>true</tt> to skip the pager.
    */
   void set_skip_pager_hint(bool skips_pager = true);
 
   
-  /** Toggles whether a window needs the user's
-   * urgent attention.
-   * 
-   * @newin2p8
-   * @param urgent <tt>true</tt> if the window is urgent.
-   */
-  void set_urgency_hint(bool urgent = true);
-
-  
   /** Moves the window into fullscreen mode. This means the
    * window covers the entire screen and is above any panels
    * or task bars.
@@ -1782,7 +1758,7 @@ public:
    * most standard window managers, and GDK makes a best effort to get
    * it to happen.
    * 
-   * @newin2p2
+   * Since: 2.2
    */
   void fullscreen();
   
@@ -1797,7 +1773,7 @@ public:
    * most standard window managers, and GDK makes a best effort to get
    * it to happen. 
    * 
-   * @newin2p2
+   * Since: 2.2
    */
   void unfullscreen();
 
@@ -1851,7 +1827,7 @@ public:
    * But it will happen with most standard window managers,
    * and GDK makes a best effort to get it to happen.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param setting Whether to keep @a window  above other windows.
    */
   void set_keep_above(bool setting = true);
@@ -1866,7 +1842,7 @@ public:
    * But it will happen with most standard window managers,
    * and GDK makes a best effort to get it to happen.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param setting Whether to keep @a window  below other windows.
    */
   void set_keep_below(bool setting = true);
@@ -1878,7 +1854,7 @@ public:
    * On X, it is the responsibility of the window manager to interpret this 
    * hint. ICCCM-compliant window manager usually respect it.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param accept_focus <tt>true</tt> if the window should receive input focus.
    */
   void set_accept_focus(bool accept_focus = true);
@@ -1893,7 +1869,7 @@ public:
    * this hint. %Window managers following the freedesktop.org window
    * manager extension specification should respect it.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param focus_on_map <tt>true</tt> if the window should receive input focus when mapped.
    */
   void set_focus_on_map(bool focus_on_map);
@@ -1903,17 +1879,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/SConscript b/libs/gtkmm2/gtk/SConscript
index feb4a24618..b4cd99f023 100644
--- a/libs/gtkmm2/gtk/SConscript
+++ b/libs/gtkmm2/gtk/SConscript
@@ -8,17 +8,7 @@ gtkmm2_files = glob.glob('gtkmm/*.cc')
 
 Import('env libraries install_prefix')
 gtkmm2 = env.Copy()
-
-gtkmm2.Append(CXXFLAGS="-DGTKMM_DISABLE_DEPRECATED")
-
-gtkmm2.Merge([ libraries['glibmm2'], 
-               libraries['gtk2'], 
-               libraries['sigc2'], 
-               libraries['pangomm'], 
-               libraries['atkmm'], 
-               libraries['gdkmm2'], 
-               libraries['cairomm'], 
-               libraries['gtk2-unix-print'] ])
+gtkmm2.Merge([libraries['glibmm2'], libraries['gtk2'], libraries['sigc2'], libraries['pangomm'], libraries['atkmm'], libraries['gdkmm2'] ])
 
 libgtkmm2 = gtkmm2.SharedLibrary('gtkmm2', gtkmm2_files)
 Default(libgtkmm2)
diff --git a/libs/gtkmm2/gtk/gtkmm.h b/libs/gtkmm2/gtk/gtkmm.h
index 91dc01ab0e..cb8411a3e3 100644
--- a/libs/gtkmm2/gtk/gtkmm.h
+++ b/libs/gtkmm2/gtk/gtkmm.h
@@ -37,21 +37,17 @@ extern const int gtkmm_micro_version;
 #include <gtkmm/alignment.h>
 #include <gtkmm/arrow.h>
 #include <gtkmm/aspectframe.h>
-#include <gtkmm/assistant.h>
 #include <gtkmm/base.h>
 #include <gtkmm/bin.h>
 #include <gtkmm/box.h>
 #include <gtkmm/button.h>
 #include <gtkmm/buttonbox.h>
-#include <gtkmm/cellview.h>
 #include <gtkmm/checkbutton.h>
 #include <gtkmm/checkmenuitem.h>
 #include <gtkmm/cellrenderer.h>
-#include <gtkmm/cellrendereraccel.h>
 #include <gtkmm/cellrenderercombo.h>
 #include <gtkmm/cellrendererpixbuf.h>
 #include <gtkmm/cellrendererprogress.h>
-#include <gtkmm/cellrendererspin.h>
 #include <gtkmm/cellrenderertext.h>
 #include <gtkmm/cellrenderertoggle.h>
 #include <gtkmm/colorbutton.h>
@@ -85,7 +81,6 @@ extern const int gtkmm_micro_version;
 #include <gtkmm/iconset.h>
 #include <gtkmm/iconfactory.h>
 #include <gtkmm/iconsource.h>
-#include <gtkmm/icontheme.h>
 #include <gtkmm/iconview.h>
 #include <gtkmm/image.h>
 #include <gtkmm/imagemenuitem.h>
@@ -94,10 +89,7 @@ extern const int gtkmm_micro_version;
 #include <gtkmm/calendar.h>
 #include <gtkmm/invisible.h>
 #include <gtkmm/label.h>
-#include <gtkmm/layout.h>
 #include <gtkmm/liststore.h>
-#include <gtkmm/listviewtext.h>
-#include <gtkmm/linkbutton.h>
 #include <gtkmm/main.h>
 #include <gtkmm/menu.h>
 #include <gtkmm/menu_elems.h>
@@ -110,29 +102,12 @@ extern const int gtkmm_micro_version;
 #include <gtkmm/object.h>
 #include <gtkmm/optionmenu.h>
 #include <gtkmm/paned.h>
-#include <gtkmm/pagesetup.h>
-#include <gtkmm/pagesetupunixdialog.h>
-#include <gtkmm/papersize.h>
-#include <gtkmm/printcontext.h>
-#include <gtkmm/printer.h>
-#include <gtkmm/printjob.h>
-#include <gtkmm/printoperation.h>
-#include <gtkmm/printoperationpreview.h>
-#include <gtkmm/printsettings.h>
-#include <gtkmm/printunixdialog.h>
 #include <gtkmm/progressbar.h>
 #include <gtkmm/radioaction.h>
 #include <gtkmm/radiobutton.h>
 #include <gtkmm/radiomenuitem.h>
 #include <gtkmm/radiotoolbutton.h>
 #include <gtkmm/range.h>
-#include <gtkmm/recentchooser.h>
-#include <gtkmm/recentchooserdialog.h>
-#include <gtkmm/recentchoosermenu.h>
-#include <gtkmm/recentchooserwidget.h>
-#include <gtkmm/recentfilter.h>
-#include <gtkmm/recentinfo.h>
-#include <gtkmm/recentmanager.h>
 #include <gtkmm/ruler.h>
 #include <gtkmm/scale.h>
 #include <gtkmm/scrollbar.h>
@@ -144,13 +119,11 @@ extern const int gtkmm_micro_version;
 #include <gtkmm/sizegroup.h>
 #include <gtkmm/spinbutton.h>
 #include <gtkmm/statusbar.h>
-#include <gtkmm/statusicon.h>
 #include <gtkmm/stock.h>
 #include <gtkmm/stockid.h>
 #include <gtkmm/stockitem.h>
 #include <gtkmm/style.h>
 #include <gtkmm/table.h>
-#include <gtkmm/tearoffmenuitem.h>
 #include <gtkmm/textbuffer.h>
 #include <gtkmm/textchildanchor.h>
 #include <gtkmm/textiter.h>
@@ -164,7 +137,6 @@ extern const int gtkmm_micro_version;
 #include <gtkmm/toolitem.h>
 #include <gtkmm/toolbutton.h>
 #include <gtkmm/toggletoolbutton.h>
-#include <gtkmm/menutoolbutton.h>
 #include <gtkmm/tooltips.h>
 #include <gtkmm/treemodel.h>
 #include <gtkmm/treemodelfilter.h>
diff --git a/libs/gtkmm2/gtk/gtkmm/aboutdialog.cc b/libs/gtkmm2/gtk/gtkmm/aboutdialog.cc
index 2ef8776d88..24b97e3b39 100644
--- a/libs/gtkmm2/gtk/gtkmm/aboutdialog.cc
+++ b/libs/gtkmm2/gtk/gtkmm/aboutdialog.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/aboutdialog.h>
 #include <gtkmm/private/aboutdialog_p.h>
 
@@ -30,32 +29,54 @@
 #include <gtk/gtklabel.h>
 
 
-//We use a function instead of a static method, so we can make it static, so it is not exported.
-static void SignalProxy_ActivateLink_gtk_callback(GtkAboutDialog* about, const gchar* link, gpointer data)
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_ActivateLink
+{
+public:
+  typedef Gtk::AboutDialog::SlotActivateLink SlotType;
+
+  SignalProxy_ActivateLink(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_ActivateLink();
+
+  static void gtk_callback(GtkAboutDialog* about, const gchar* link, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_ActivateLink::~SignalProxy_ActivateLink()
+{}
+
+void SignalProxy_ActivateLink::gtk_callback(GtkAboutDialog* about, const gchar* link, gpointer data)
 {
-  Gtk::AboutDialog::SlotActivateLink* the_slot = static_cast<Gtk::AboutDialog::SlotActivateLink*>(data);
+  SignalProxy_ActivateLink *const self = static_cast<SignalProxy_ActivateLink*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Gtk::AboutDialog* pCppAbout = Glib::wrap(about);
-    (*the_slot)( *pCppAbout, Glib::convert_const_gchar_ptr_to_ustring(link) );
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)( *pCppAbout, Glib::convert_const_gchar_ptr_to_ustring(link) );
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+
 }
 
-static void SignalProxy_ActivateLink_gtk_callback_destroy(void* data)
+void SignalProxy_ActivateLink::gtk_callback_destroy(void* data)
 {
-  Gtk::AboutDialog::SlotActivateLink* the_slot = static_cast<Gtk::AboutDialog::SlotActivateLink*>(data);
-  delete the_slot;
+  delete static_cast<SignalProxy_ActivateLink*>(data);
 }
 
+} // anonymous namespace
+
 
 namespace Gtk
 {
@@ -63,27 +84,27 @@ namespace Gtk
 //static:
 void AboutDialog::set_email_hook(const SlotActivateLink& slot)
 {
-  // Create a copy of the slot object. A pointer to this will be passed
+  // Create a signal proxy.  A pointer to this will be passed
   // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_SlotForwardPage_gtk_callback_destroy() is called.
-  SlotActivateLink* slot_copy = new SlotActivateLink(slot);
+  // when SignalProxy_ActivateLink::gtk_callback_destroy() is called.
+  SignalProxy_ActivateLink *const pSignalProxy = new SignalProxy_ActivateLink(slot);
 
   gtk_about_dialog_set_email_hook(
-      &SignalProxy_ActivateLink_gtk_callback, slot_copy,
-      &SignalProxy_ActivateLink_gtk_callback_destroy);
+      &SignalProxy_ActivateLink::gtk_callback, pSignalProxy,
+      &SignalProxy_ActivateLink::gtk_callback_destroy);
 }
   
 //static:
 void AboutDialog::set_url_hook(const SlotActivateLink& slot)
 {
-  // Create a copy of the slot object. A pointer to this will be passed
+  // Create a signal proxy.  A pointer to this will be passed
   // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_SlotForwardPage_gtk_callback_destroy() is called.
-  SlotActivateLink* slot_copy = new SlotActivateLink(slot);
+  // when SignalProxy_ActivateLink::gtk_callback_destroy() is called.
+  SignalProxy_ActivateLink *const pSignalProxy = new SignalProxy_ActivateLink(slot);
 
   gtk_about_dialog_set_url_hook(
-      &SignalProxy_ActivateLink_gtk_callback, slot_copy,
-      &SignalProxy_ActivateLink_gtk_callback_destroy);
+      &SignalProxy_ActivateLink::gtk_callback, pSignalProxy,
+      &SignalProxy_ActivateLink::gtk_callback_destroy);
 } 
 
 } // namespace Gtk
@@ -135,19 +156,8 @@ void AboutDialog_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* AboutDialog_Class::wrap_new(GObject* o)
 {
@@ -202,7 +212,7 @@ Glib::ustring AboutDialog::get_name() const
 
 void AboutDialog::set_name(const Glib::ustring& name)
 {
-gtk_about_dialog_set_name(gobj(), name.c_str()); 
+  gtk_about_dialog_set_name(gobj(), name.c_str());
 }
 
 Glib::ustring AboutDialog::get_version() const
@@ -212,7 +222,7 @@ Glib::ustring AboutDialog::get_version() const
 
 void AboutDialog::set_version(const Glib::ustring& version)
 {
-gtk_about_dialog_set_version(gobj(), version.c_str()); 
+  gtk_about_dialog_set_version(gobj(), version.c_str());
 }
 
 Glib::ustring AboutDialog::get_copyright() const
@@ -222,7 +232,7 @@ Glib::ustring AboutDialog::get_copyright() const
 
 void AboutDialog::set_copyright(const Glib::ustring& copyright)
 {
-gtk_about_dialog_set_copyright(gobj(), copyright.c_str()); 
+  gtk_about_dialog_set_copyright(gobj(), copyright.c_str());
 }
 
 Glib::ustring AboutDialog::get_comments() const
@@ -232,7 +242,7 @@ Glib::ustring AboutDialog::get_comments() const
 
 void AboutDialog::set_comments(const Glib::ustring& comments)
 {
-gtk_about_dialog_set_comments(gobj(), comments.c_str()); 
+  gtk_about_dialog_set_comments(gobj(), comments.c_str());
 }
 
 Glib::ustring AboutDialog::get_license() const
@@ -242,7 +252,7 @@ Glib::ustring AboutDialog::get_license() const
 
 void AboutDialog::set_license(const Glib::ustring& license)
 {
-gtk_about_dialog_set_license(gobj(), license.c_str()); 
+  gtk_about_dialog_set_license(gobj(), license.c_str());
 }
 
 Glib::ustring AboutDialog::get_website() const
@@ -252,7 +262,7 @@ Glib::ustring AboutDialog::get_website() const
 
 void AboutDialog::set_website(const Glib::ustring& website)
 {
-gtk_about_dialog_set_website(gobj(), website.c_str()); 
+  gtk_about_dialog_set_website(gobj(), website.c_str());
 }
 
 Glib::ustring AboutDialog::get_website_label() const
@@ -262,7 +272,7 @@ Glib::ustring AboutDialog::get_website_label() const
 
 void AboutDialog::set_website_label(const Glib::ustring& website_label)
 {
-gtk_about_dialog_set_website_label(gobj(), website_label.c_str()); 
+  gtk_about_dialog_set_website_label(gobj(), website_label.c_str());
 }
 
 Glib::StringArrayHandle AboutDialog::get_authors() const
@@ -272,7 +282,7 @@ Glib::StringArrayHandle AboutDialog::get_authors() const
 
 void AboutDialog::set_authors(const Glib::StringArrayHandle& authors) const
 {
-gtk_about_dialog_set_authors(const_cast<GtkAboutDialog*>(gobj()), const_cast<const gchar**>((authors).data())); 
+  gtk_about_dialog_set_authors(const_cast<GtkAboutDialog*>(gobj()), const_cast<const gchar**>((authors).data()));
 }
 
 Glib::StringArrayHandle AboutDialog::get_documenters() const
@@ -282,7 +292,7 @@ Glib::StringArrayHandle AboutDialog::get_documenters() const
 
 void AboutDialog::set_documenters(const Glib::StringArrayHandle& documenters)
 {
-gtk_about_dialog_set_documenters(gobj(), const_cast<const gchar**>((documenters).data())); 
+  gtk_about_dialog_set_documenters(gobj(), const_cast<const gchar**>((documenters).data()));
 }
 
 Glib::StringArrayHandle AboutDialog::get_artists() const
@@ -292,7 +302,7 @@ Glib::StringArrayHandle AboutDialog::get_artists() const
 
 void AboutDialog::set_artists(const Glib::StringArrayHandle& artists)
 {
-gtk_about_dialog_set_artists(gobj(), const_cast<const gchar**>((artists).data())); 
+  gtk_about_dialog_set_artists(gobj(), const_cast<const gchar**>((artists).data()));
 }
 
 Glib::ustring AboutDialog::get_translator_credits() const
@@ -302,7 +312,7 @@ Glib::ustring AboutDialog::get_translator_credits() const
 
 void AboutDialog::set_translator_credits(const Glib::ustring& translator_credits)
 {
-gtk_about_dialog_set_translator_credits(gobj(), translator_credits.c_str()); 
+  gtk_about_dialog_set_translator_credits(gobj(), translator_credits.c_str());
 }
 
 Glib::RefPtr<Gdk::Pixbuf> AboutDialog::get_logo()
@@ -312,12 +322,12 @@ Glib::RefPtr<Gdk::Pixbuf> AboutDialog::get_logo()
 
 Glib::RefPtr<const Gdk::Pixbuf> AboutDialog::get_logo() const
 {
-  return const_cast<AboutDialog*>(this)->get_logo();
+  return Glib::wrap(gtk_about_dialog_get_logo(const_cast<GtkAboutDialog*>(gobj())));
 }
 
 void AboutDialog::set_logo(const Glib::RefPtr<Gdk::Pixbuf>& logo)
 {
-gtk_about_dialog_set_logo(gobj(), Glib::unwrap(logo)); 
+  gtk_about_dialog_set_logo(gobj(), Glib::unwrap(logo));
 }
 
 Glib::ustring AboutDialog::get_logo_icon_name() const
@@ -327,222 +337,139 @@ Glib::ustring AboutDialog::get_logo_icon_name() const
 
 void AboutDialog::set_logo_icon_name(const Glib::ustring& icon_name)
 {
-gtk_about_dialog_set_logo_icon_name(gobj(), icon_name.c_str()); 
-}
-
-bool AboutDialog::get_wrap_license() const
-{
-  return gtk_about_dialog_get_wrap_license(const_cast<GtkAboutDialog*>(gobj()));
-}
-
-void AboutDialog::set_wrap_license(bool wrap_license)
-{
-gtk_about_dialog_set_wrap_license(gobj(), static_cast<int>(wrap_license)); 
+  gtk_about_dialog_set_logo_icon_name(gobj(), icon_name.c_str());
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_version() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "version");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_version() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "version");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_copyright() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "copyright");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_copyright() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "copyright");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_comments() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "comments");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_comments() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "comments");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_website() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "website");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_website() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "website");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_website_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "website-label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_website_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "website-label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_license() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "license");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_license() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "license");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_authors() 
 {
   return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "authors");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_authors() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "authors");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_documenters() 
 {
   return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "documenters");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_documenters() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "documenters");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_translator_credits() 
 {
   return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "translator-credits");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_translator_credits() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "translator-credits");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::StringArrayHandle> AboutDialog::property_artists() 
 {
   return Glib::PropertyProxy<Glib::StringArrayHandle>(this, "artists");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> AboutDialog::property_artists() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle>(this, "artists");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > AboutDialog::property_logo() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "logo");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > AboutDialog::property_logo() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "logo");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> AboutDialog::property_logo_icon_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "logo-icon-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> AboutDialog::property_logo_icon_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "logo-icon-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> AboutDialog::property_wrap_license() 
-{
-  return Glib::PropertyProxy<bool>(this, "wrap-license");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> AboutDialog::property_wrap_license() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap-license");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/aboutdialog.h b/libs/gtkmm2/gtk/gtkmm/aboutdialog.h
index 7e7a22b2af..d36c8b2326 100644
--- a/libs/gtkmm2/gtk/gtkmm/aboutdialog.h
+++ b/libs/gtkmm2/gtk/gtkmm/aboutdialog.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ABOUTDIALOG_H
 #define _GTKMM_ABOUTDIALOG_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -42,16 +41,7 @@ namespace Gtk
 namespace Gtk
 {
 
-/** The AboutDialog offers a simple way to display information about a program like its logo, name, copyright, 
- * website and license. It is also possible to give credits to the authors, documenters, translators and artists 
- * who have worked on the program. An about dialog is typically opened when the user selects the About option 
- * from the Help menu. All parts of the dialog are optional.
- *
- * About dialogs often contain links and email addresses. Gtk::AboutDialog supports this by offering global 
- * hooks, which are called when the user clicks on a link or email address, see set_email_hook() and 
- * set_url_hook(). Email addresses in the authors, documenters and artists properties are recognized by looking 
- * for <user@host>, URLs are recognized by looking for http://url, with the URL extending to the next space, 
- * tab or line break.
+/** TODO
  *
  * @ingroup Dialogs
  */
@@ -99,17 +89,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -123,14 +107,14 @@ public:
    * @return The program name. The string is owned by the about
    * dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_name() const;
   
   /** Sets the name to display in the about dialog. 
    * If this is not set, it defaults to Glib::get_application_name().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param name The program name.
    */
   void set_name(const Glib::ustring& name);
@@ -139,13 +123,13 @@ public:
    * @return The version string. The string is owned by the about
    * dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_version() const;
   
   /** Sets the version string to display in the about dialog.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param version The version string.
    */
   void set_version(const Glib::ustring& version);
@@ -154,14 +138,14 @@ public:
    * @return The copyright string. The string is owned by the about
    * dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_copyright() const;
   
   /** Sets the copyright string to display in the about dialog.
    * This should be a short string of one or two lines. 
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param copyright The copyright string.
    */
   void set_copyright(const Glib::ustring& copyright);
@@ -170,7 +154,7 @@ public:
    * @return The comments. The string is owned by the about
    * dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_comments() const;
   
@@ -178,7 +162,7 @@ public:
    * dialog. This should be a short string of one or
    * two lines.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param comments A comments string.
    */
   void set_comments(const Glib::ustring& comments);
@@ -187,7 +171,7 @@ public:
    * @return The license information. The string is owned by the about
    * dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_license() const;
   
@@ -195,7 +179,7 @@ public:
    * license dialog. If @a license  is <tt>0</tt>, the license button is
    * hidden.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param license The license information or <tt>0</tt>.
    */
   void set_license(const Glib::ustring& license);
@@ -204,13 +188,13 @@ public:
    * @return The website URL. The string is owned by the about
    * dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_website() const;
   
   /** Sets the URL to use for the website link.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param website A URL string starting with "http://".
    */
   void set_website(const Glib::ustring& website);
@@ -219,18 +203,18 @@ public:
    * @return The label used for the website link. The string is owned by the about
    * dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_website_label() const;
   
   /** Sets the label to be used for the website link.
    * It defaults to the website URL.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param website_label The label used for the website link.
    */
   void set_website_label(const Glib::ustring& website_label);
-
+  
    
   /** Returns the string which are displayed in the authors tab
    * of the secondary credits dialog.
@@ -238,19 +222,19 @@ public:
    * the authors. The array is owned by the about dialog 
    * and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::StringArrayHandle get_authors() const;
-
+  
   
   /** Sets the strings which are displayed in the authors tab
    * of the secondary credits dialog. 
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param authors A <tt>0</tt>-terminated array of strings.
    */
   void set_authors(const Glib::StringArrayHandle& authors) const;
-
+  
   
   /** Returns the string which are displayed in the documenters 
    * tab of the secondary credits dialog.
@@ -258,15 +242,15 @@ public:
    * the documenters. The array is owned by the about dialog 
    * and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::StringArrayHandle get_documenters() const;
-
+  
    
   /** Sets the strings which are displayed in the documenters tab
    * of the secondary credits dialog. 
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param documenters A <tt>0</tt>-terminated array of strings.
    */
   void set_documenters(const Glib::StringArrayHandle& documenters);
@@ -277,14 +261,14 @@ public:
    * the artists. The array is owned by the about dialog 
    * and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::StringArrayHandle get_artists() const;
   
   /** Sets the strings which are displayed in the artists tab
    * of the secondary credits dialog. 
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param artists A <tt>0</tt>-terminated array of strings.
    */
   void set_artists(const Glib::StringArrayHandle& artists);
@@ -294,7 +278,7 @@ public:
    * @return The translator credits string. The string is
    * owned by the about dialog and must not be modified.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_translator_credits() const;
   
@@ -313,18 +297,18 @@ public:
    * since Gtk::AboutDialog will detect if "translator-credits" is untranslated
    * and hide the tab.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param translator_credits The translator credits.
    */
   void set_translator_credits(const Glib::ustring& translator_credits);
-
+  
   
   /** Returns the pixbuf displayed as logo in the about dialog.
    * @return The pixbuf displayed as logo. The pixbuf is
    * owned by the about dialog. If you want to keep a reference
    * to it, you have to call Glib::object_ref() on it.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<Gdk::Pixbuf> get_logo();
   
@@ -333,7 +317,7 @@ public:
    * owned by the about dialog. If you want to keep a reference
    * to it, you have to call Glib::object_ref() on it.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<const Gdk::Pixbuf> get_logo() const;
 
@@ -343,18 +327,18 @@ public:
    * window icon set with Gtk::Window::set_default_icon()
    * will be used.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param logo A Gdk::Pixbuf, or <tt>0</tt>.
    */
   void set_logo(const Glib::RefPtr<Gdk::Pixbuf>& logo);
-
+  
   
   /** Returns the icon name displayed as logo in the about dialog.
    * @return The icon name displayed as logo. The string is
-   * owned by the dialog. If you want to keep a reference
+   * owned by the about dialog. If you want to keep a reference
    * to it, you have to call Glib::strdup() on it.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_logo_icon_name() const;
   
@@ -363,57 +347,31 @@ public:
    * window icon set with Gtk::Window::set_default_icon()
    * will be used.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param icon_name An icon name, or <tt>0</tt>.
    */
   void set_logo_icon_name(const Glib::ustring& icon_name);
 
-  
-  /** Returns whether the license text in @a about  is 
-   * automatically wrapped.
-   * @return <tt>true</tt> if the license text is wrapped 
-   * 
-   * @newin2p8.
-   */
-  bool get_wrap_license() const;
-  
-  /** Sets whether the license text in @a about  is 
-   * automatically wrapped.
-   * 
-   * @newin2p8
-   * @param wrap_license Whether to wrap the license.
-   */
-  void set_wrap_license(bool wrap_license);
-
   /** For instance,
    * void on_activate_link_url(AboutDialog& about_dialog, const Glib::ustring& link);
    */
   typedef sigc::slot<void, AboutDialog& /* about_dialog */, const Glib::ustring& /* link */> SlotActivateLink;
-
-  /** Installs a global callback to be called whenever the user activates an email link in an about dialog.
-   * @param slot A function or method to call when an email link is activated.
-   */
+  
+  //TODO: Document these methods.
   static void set_email_hook(const SlotActivateLink& slot);
   
-
-  /** Installs a global callback to be called whenever the user activates a URL link in an about dialog.
-   * @param slot A function or method to call when a URL link is activated.
-   */
+  
   static void set_url_hook(const SlotActivateLink& slot);
   
-
-//TODO: Deprecate this, because it conflicts with the property in GtkWidget, which will be deprecated in GTK+ 2.12.
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The name of the program. If this is not set
+  
+  /** The name of the program. If this is not 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<Glib::ustring> property_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The name of the program. If this is not set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -421,20 +379,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The version of the program.
+  /** The version of the program.
    *
    * 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_version() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The version of the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -442,19 +395,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_version() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Copyright information for the program.
+  /** Copyright information for the program.
    *
    * 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_copyright() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Copyright information for the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -462,19 +411,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_copyright() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Comments about the program.
+  /** Comments about the program.
    *
    * 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_comments() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Comments about the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -482,19 +427,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_comments() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The URL for the link to the website of the program.
+  /** The URL for the link to the website of the program.
    *
    * 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_website() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The URL for the link to the website of the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -502,19 +443,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_website() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The label for the link to the website of the program. If this is not set
+  /** The label for the link to the website of the program. If this is not 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<Glib::ustring> property_website_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The label for the link to the website of the program. If this is not set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -522,19 +459,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_website_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The license of the program.
+  /** The license of the program.
    *
    * 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_license() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The license of the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -542,19 +475,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_license() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** List of authors of the program.
+  /** List of authors of the program.
    *
    * 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::StringArrayHandle> property_authors() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** List of authors of the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -562,19 +491,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_authors() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** List of people documenting the program.
+  /** List of people documenting the program.
    *
    * 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::StringArrayHandle> property_documenters() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** List of people documenting the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -582,19 +507,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_documenters() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Credits to the translators. This string should be marked as translatable.
+  /** Credits to the translators. This string should be marked as translatable.
    *
    * 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::StringArrayHandle> property_translator_credits() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Credits to the translators. This string should be marked as translatable.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -602,19 +523,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_translator_credits() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** List of people who have contributed artwork to the program.
+  /** List of people who have contributed artwork to the program.
    *
    * 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::StringArrayHandle> property_artists() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** List of people who have contributed artwork to the program.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -622,19 +539,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::StringArrayHandle> property_artists() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A logo for the about box. If this is not set
+  /** A logo for the about box. If this is not 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< Glib::RefPtr<Gdk::Pixbuf> > property_logo() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A logo for the about box. If this is not set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -642,19 +555,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_logo() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A named icon to use as the logo for the about box.
+  /** A named icon to use as the logo for the about box.
    *
    * 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_logo_icon_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A named icon to use as the logo for the about box.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -662,27 +571,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_logo_icon_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-  
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to wrap the license 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<bool> property_wrap_license() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to wrap the license 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<bool> property_wrap_license() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
   
 
 };
@@ -698,8 +586,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::AboutDialog* wrap(GtkAboutDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ABOUTDIALOG_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/accelgroup.cc b/libs/gtkmm2/gtk/gtkmm/accelgroup.cc
index fcc972de58..edb7170bf4 100644
--- a/libs/gtkmm2/gtk/gtkmm/accelgroup.cc
+++ b/libs/gtkmm2/gtk/gtkmm/accelgroup.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/accelgroup.h>
 #include <gtkmm/private/accelgroup_p.h>
 
@@ -66,8 +65,7 @@ Gdk::ModifierType AccelGroup::get_default_mod_mask()
 namespace
 {
 
-
-static gboolean AccelGroup_signal_accel_activate_callback(GtkAccelGroup* self, GObject* p0,guint p1,GdkModifierType p2,void* data)
+gboolean AccelGroup_signal_accel_activate_callback(GtkAccelGroup* self, GObject* p0,guint p1,GdkModifierType p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > SlotType;
@@ -75,28 +73,24 @@ static gboolean AccelGroup_signal_accel_activate_callback(GtkAccelGroup* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1, ((Gdk::ModifierType)(p2))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean AccelGroup_signal_accel_activate_notify_callback(GtkAccelGroup* self, GObject* p0,guint p1,GdkModifierType p2, void* data)
+gboolean AccelGroup_signal_accel_activate_notify_callback(GtkAccelGroup* self, GObject* p0,guint p1,GdkModifierType p2, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > SlotType;
@@ -104,28 +98,24 @@ static gboolean AccelGroup_signal_accel_activate_notify_callback(GtkAccelGroup*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1, ((Gdk::ModifierType)(p2))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo AccelGroup_signal_accel_activate_info =
+const Glib::SignalProxyInfo AccelGroup_signal_accel_activate_info =
 {
   "accel_activate",
   (GCallback) &AccelGroup_signal_accel_activate_callback,
@@ -133,7 +123,7 @@ static const Glib::SignalProxyInfo AccelGroup_signal_accel_activate_info =
 };
 
 
-static void AccelGroup_signal_accel_changed_callback(GtkAccelGroup* self, guint p0,GdkModifierType p1,GClosure* p2,void* data)
+void AccelGroup_signal_accel_changed_callback(GtkAccelGroup* self, guint p0,GdkModifierType p1,GClosure* p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,guint,Gdk::ModifierType,GClosure* > SlotType;
@@ -141,31 +131,26 @@ static void AccelGroup_signal_accel_changed_callback(GtkAccelGroup* self, guint
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0, ((Gdk::ModifierType)(p1))
 , p2);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo AccelGroup_signal_accel_changed_info =
+const Glib::SignalProxyInfo AccelGroup_signal_accel_changed_info =
 {
   "accel_changed",
   (GCallback) &AccelGroup_signal_accel_changed_callback,
   (GCallback) &AccelGroup_signal_accel_changed_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -212,18 +197,10 @@ void AccelGroup_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->accel_changed = &accel_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void AccelGroup_Class::accel_changed_callback(GtkAccelGroup* self, guint p0, GdkModifierType p1, GClosure* p2)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -236,20 +213,16 @@ void AccelGroup_Class::accel_changed_callback(GtkAccelGroup* self, guint p0, Gdk
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_accel_changed(p0, ((Gdk::ModifierType)(p1))
 , p2);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -262,7 +235,6 @@ void AccelGroup_Class::accel_changed_callback(GtkAccelGroup* self, guint p0, Gdk
       (*base->accel_changed)(self, p0, p1, p2);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* AccelGroup_Class::wrap_new(GObject* object)
@@ -319,12 +291,12 @@ Glib::RefPtr<AccelGroup> AccelGroup::create()
 }
 void AccelGroup::lock()
 {
-gtk_accel_group_lock(gobj()); 
+  gtk_accel_group_lock(gobj());
 }
 
 void AccelGroup::unlock()
 {
-gtk_accel_group_unlock(gobj()); 
+  gtk_accel_group_unlock(gobj());
 }
 
 bool AccelGroup::disconnect_key(guint accel_key, Gdk::ModifierType accel_mods)
@@ -337,7 +309,6 @@ Glib::ustring AccelGroup::get_label(guint accelerator_key, Gdk::ModifierType acc
   return Glib::convert_return_gchar_ptr_to_ustring(gtk_accelerator_get_label(accelerator_key, ((GdkModifierType)(accelerator_mods))));
 }
 
-
 bool AccelGroup::activate(GQuark accel_quark, const Glib::RefPtr<Glib::Object>& acceleratable, guint accel_key, Gdk::ModifierType accel_mods)
 {
   return gtk_accel_group_activate(gobj(), accel_quark, Glib::unwrap(acceleratable), accel_key, ((GdkModifierType)(accel_mods)));
@@ -354,14 +325,12 @@ Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierTy
   return Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType >(this, &AccelGroup_signal_accel_activate_info);
 }
 
-
 Glib::SignalProxy3< void,guint,Gdk::ModifierType,GClosure* > AccelGroup::signal_accel_changed()
 {
   return Glib::SignalProxy3< void,guint,Gdk::ModifierType,GClosure* >(this, &AccelGroup_signal_accel_changed_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::AccelGroup::on_accel_changed(guint keyval, Gdk::ModifierType modifier, GClosure* accel_closure)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -371,10 +340,6 @@ void Gtk::AccelGroup::on_accel_changed(guint keyval, Gdk::ModifierType modifier,
   if(base && base->accel_changed)
     (*base->accel_changed)(gobj(),keyval,((GdkModifierType)(modifier)),accel_closure);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/accelgroup.h b/libs/gtkmm2/gtk/gtkmm/accelgroup.h
index 62190dae65..1a6a8adc4d 100644
--- a/libs/gtkmm2/gtk/gtkmm/accelgroup.h
+++ b/libs/gtkmm2/gtk/gtkmm/accelgroup.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ACCELGROUP_H
 #define _GTKMM_ACCELGROUP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -165,7 +164,7 @@ public:
    * @param accelerator_mods Accelerator modifier mask.
    * @return A newly-allocated string representing the accelerator.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   static Glib::ustring get_label(guint accelerator_key, Gdk::ModifierType accelerator_mods);
 
@@ -209,20 +208,11 @@ public:
 
   //TODO: Discover real parameter names:
   
-/**
-   * @par Prototype:
-   * <tt>bool %accel_activate(const Glib::RefPtr<Glib::Object>& object, guint param2, Gdk::ModifierType param3)</tt>
-   */
 
   Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,guint,Gdk::ModifierType > signal_accel_activate();
    
   //TODO: The C type is unpleasant:
-  //This has C docs, but it isn't worth mentioning them for such a useless signal. murrayc.
   
-/**
-   * @par Prototype:
-   * <tt>void %accel_changed(guint keyval, Gdk::ModifierType modifier, GClosure* accel_closure)</tt>
-   */
 
   Glib::SignalProxy3< void,guint,Gdk::ModifierType,GClosure* > signal_accel_changed();
 
@@ -231,18 +221,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_accel_changed(guint keyval, Gdk::ModifierType modifier, GClosure* accel_closure);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/accellabel.cc b/libs/gtkmm2/gtk/gtkmm/accellabel.cc
index f884b7d606..d62bc75418 100644
--- a/libs/gtkmm2/gtk/gtkmm/accellabel.cc
+++ b/libs/gtkmm2/gtk/gtkmm/accellabel.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/accellabel.h>
 #include <gtkmm/private/accellabel_p.h>
 
@@ -98,19 +97,8 @@ void AccelLabel_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* AccelLabel_Class::wrap_new(GObject* o)
 {
@@ -160,7 +148,7 @@ AccelLabel::AccelLabel()
 
 void AccelLabel::set_accel_widget(const Widget& accel_widget)
 {
-gtk_accel_label_set_accel_widget(gobj(), const_cast<GtkWidget*>((accel_widget).gobj())); 
+  gtk_accel_label_set_accel_widget(gobj(), const_cast<GtkWidget*>((accel_widget).gobj()));
 }
 
 Widget* AccelLabel::get_accel_widget()
@@ -170,7 +158,7 @@ Widget* AccelLabel::get_accel_widget()
 
 const Widget* AccelLabel::get_accel_widget() const
 {
-  return const_cast<AccelLabel*>(this)->get_accel_widget();
+  return Glib::wrap(gtk_accel_label_get_accel_widget(const_cast<GtkAccelLabel*>(gobj())));
 }
 
 guint AccelLabel::get_accel_width() const
@@ -184,26 +172,15 @@ bool AccelLabel::refetch()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Widget*> AccelLabel::property_accel_widget() 
 {
   return Glib::PropertyProxy<Gtk::Widget*>(this, "accel-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Widget*> AccelLabel::property_accel_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "accel-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/accellabel.h b/libs/gtkmm2/gtk/gtkmm/accellabel.h
index 2c057671fa..a4d6a32645 100644
--- a/libs/gtkmm2/gtk/gtkmm/accellabel.h
+++ b/libs/gtkmm2/gtk/gtkmm/accellabel.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ACCELLABEL_H
 #define _GTKMM_ACCELLABEL_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -90,17 +89,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -154,17 +147,14 @@ public:
   bool refetch();
 
   //_WRAP_PROPERTY("accel-closure", Glib::Object) //GClosure
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The widget to be monitored for accelerator changes.
+  /** The widget to be monitored for accelerator changes.
    *
    * 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_accel_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The widget to be monitored for accelerator changes.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -172,7 +162,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_accel_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -188,8 +177,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::AccelLabel* wrap(GtkAccelLabel* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ACCELLABEL_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/accelmap.cc b/libs/gtkmm2/gtk/gtkmm/accelmap.cc
index 6b9c31c7fe..1d87a7cd64 100644
--- a/libs/gtkmm2/gtk/gtkmm/accelmap.cc
+++ b/libs/gtkmm2/gtk/gtkmm/accelmap.cc
@@ -64,24 +64,6 @@ void unlock_path(const std::string& accel_path)
   gtk_accel_map_unlock_path(accel_path.c_str());
 }
 
-bool lookup_entry(const Glib::ustring& accel_path, Gtk::AccelKey& key)
-{
-  GtkAccelKey gkey = {GDK_VoidSymbol, GdkModifierType (0), 0};
-  const bool known = gtk_accel_map_lookup_entry(accel_path.c_str(), &gkey);
-
-  if(known)
-    key = AccelKey(gkey.accel_key, Gdk::ModifierType (gkey.accel_mods));
-  else
-    key = AccelKey(GDK_VoidSymbol, Gdk::ModifierType (0));
-
-  return known;
-}
-
-bool lookup_entry(const Glib::ustring& accel_path)
-{
-  return gtk_accel_map_lookup_entry(accel_path.c_str(), 0 /* "optional", according to the C docs. */);
-}
-
 } // namespace AccelMap
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/accelmap.h b/libs/gtkmm2/gtk/gtkmm/accelmap.h
index 03440b359d..00dd8b9a1f 100644
--- a/libs/gtkmm2/gtk/gtkmm/accelmap.h
+++ b/libs/gtkmm2/gtk/gtkmm/accelmap.h
@@ -26,7 +26,6 @@
 #include <string>
 
 #include <gdkmm/types.h>
-#include <gtkmm/accelkey.h>
 
 namespace Gtk
 {
@@ -108,8 +107,8 @@ void save(const std::string& filename);
  *
  * @param accel_path a valid accelerator path
  *
- * @newin2p4
- */
+ * Since: 2.4
+ **/
 void lock_path(const std::string& accel_path);
 
 /** Unlocks the given accelerator path. Refer to gtk_accel_map_lock_path()
@@ -117,27 +116,10 @@ void lock_path(const std::string& accel_path);
  *
  * @param accel_path a valid accelerator path
  *
- * @newin2p4
- */
+ * Since: 2.4
+ **/
 void unlock_path(const std::string& accel_path);
 
-/** Looks up the accelerator entry for accel_path.
- * @param accel_path A valid accelerator path.
- * @result true if accel_path is known, false otherwise
- *
- * @newin2p10
- */
-bool lookup_entry (const Glib::ustring& accel_path);
-
-/** Looks up the accelerator entry for accel_path and fills in key.
- * @param accel_path A valid accelerator path.
- * @param key The accelerator key to be filled in.
- * @result true if accel_path is known, false otherwise
- *
- * @newin2p10
- */
-bool lookup_entry (const Glib::ustring& accel_path, Gtk::AccelKey& key);
-
 } // namespace AccelMap
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/action.cc b/libs/gtkmm2/gtk/gtkmm/action.cc
index 9ddf165d8e..1504ee29c2 100644
--- a/libs/gtkmm2/gtk/gtkmm/action.cc
+++ b/libs/gtkmm2/gtk/gtkmm/action.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/action.h>
 #include <gtkmm/private/action_p.h>
 
@@ -29,9 +28,6 @@
 #include <gtkmm/menuitem.h>
 #include <gtkmm/toolitem.h>
 #include <gtkmm/image.h>
-#include <gtkmm/widget.h>
-
-typedef Gtk::Action Action; 
 
 namespace Gtk
 {
@@ -55,13 +51,9 @@ Glib::RefPtr<Action> Action::create(const Glib::ustring& name, const Gtk::StockI
 
 void Action::set_tooltip(const Glib::ustring& tooltip)
 {
-#ifdef GLIBMM_PROPERTIES_ENABLED
   property_tooltip() = tooltip;
-#else
-  set_property("tooltip", tooltip);
-#endif
 }
-
+  
 
 } // namespace Gtk
 
@@ -69,15 +61,13 @@ void Action::set_tooltip(const Glib::ustring& tooltip)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Action_signal_activate_info =
+const Glib::SignalProxyInfo Action_signal_activate_info =
 {
   "activate",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -124,19 +114,13 @@ void Action_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->create_menu_item = &create_menu_item_vfunc_callback;
   klass->create_tool_item = &create_tool_item_vfunc_callback;
   klass->connect_proxy = &connect_proxy_vfunc_callback;
   klass->disconnect_proxy = &disconnect_proxy_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->activate = &activate_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 GtkWidget* Action_Class::create_menu_item_vfunc_callback(GtkAction* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -149,19 +133,15 @@ GtkWidget* Action_Class::create_menu_item_vfunc_callback(GtkAction* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return (GtkWidget*)Glib::unwrap(obj->create_menu_item_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -177,6 +157,7 @@ GtkWidget* Action_Class::create_menu_item_vfunc_callback(GtkAction* self)
   typedef GtkWidget* RType;
   return RType();
 }
+
 GtkWidget* Action_Class::create_tool_item_vfunc_callback(GtkAction* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -189,19 +170,15 @@ GtkWidget* Action_Class::create_tool_item_vfunc_callback(GtkAction* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return (GtkWidget*)Glib::unwrap(obj->create_tool_item_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -217,6 +194,7 @@ GtkWidget* Action_Class::create_tool_item_vfunc_callback(GtkAction* self)
   typedef GtkWidget* RType;
   return RType();
 }
+
 void Action_Class::connect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -229,20 +207,16 @@ void Action_Class::connect_proxy_vfunc_callback(GtkAction* self, GtkWidget* prox
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->connect_proxy_vfunc(Glib::wrap(proxy)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -255,6 +229,7 @@ void Action_Class::connect_proxy_vfunc_callback(GtkAction* self, GtkWidget* prox
       (*base->connect_proxy)(self, proxy);
   }
 }
+
 void Action_Class::disconnect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -267,20 +242,16 @@ void Action_Class::disconnect_proxy_vfunc_callback(GtkAction* self, GtkWidget* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->disconnect_proxy_vfunc(Glib::wrap(proxy)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -293,9 +264,8 @@ void Action_Class::disconnect_proxy_vfunc_callback(GtkAction* self, GtkWidget* p
       (*base->disconnect_proxy)(self, proxy);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Action_Class::activate_callback(GtkAction* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -308,19 +278,15 @@ void Action_Class::activate_callback(GtkAction* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_activate();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -333,7 +299,6 @@ void Action_Class::activate_callback(GtkAction* self)
       (*base->activate)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Action_Class::wrap_new(GObject* object)
@@ -405,7 +370,7 @@ bool Action::get_sensitive() const
 
 void Action::set_sensitive(bool sensitive)
 {
-gtk_action_set_sensitive(gobj(), static_cast<int>(sensitive)); 
+  gtk_action_set_sensitive(gobj(), static_cast<int>(sensitive));
 }
 
 bool Action::is_visible() const
@@ -420,12 +385,12 @@ bool Action::get_visible() const
 
 void Action::set_visible(bool visible)
 {
-gtk_action_set_visible(gobj(), static_cast<int>(visible)); 
+  gtk_action_set_visible(gobj(), static_cast<int>(visible));
 }
 
 void Action::activate()
 {
-gtk_action_activate(gobj()); 
+  gtk_action_activate(gobj());
 }
 
 Image* Action::create_icon(IconSize icon_size)
@@ -445,32 +410,32 @@ ToolItem* Action::create_tool_item()
 
 void Action::connect_proxy(Widget& proxy)
 {
-gtk_action_connect_proxy(gobj(), (proxy).gobj()); 
+  gtk_action_connect_proxy(gobj(), (proxy).gobj());
 }
 
 void Action::disconnect_proxy(Widget& proxy)
 {
-gtk_action_disconnect_proxy(gobj(), (proxy).gobj()); 
+  gtk_action_disconnect_proxy(gobj(), (proxy).gobj());
 }
 
 Glib::SListHandle<Widget*> Action::get_proxies()
 {
-  return Glib::SListHandle<Widget*>(gtk_action_get_proxies(gobj()), Glib::OWNERSHIP_NONE);
+  return Glib::SListHandle<Widget*>(gtk_action_get_proxies(gobj()), Glib::OWNERSHIP_SHALLOW);
 }
 
 Glib::SListHandle<const Widget*> Action::get_proxies() const
 {
-  return Glib::SListHandle<const Widget*>(gtk_action_get_proxies(const_cast<GtkAction*>(gobj())), Glib::OWNERSHIP_NONE);
+  return Glib::SListHandle<const Widget*>(gtk_action_get_proxies(const_cast<GtkAction*>(gobj())), Glib::OWNERSHIP_SHALLOW);
 }
 
 void Action::connect_accelerator()
 {
-gtk_action_connect_accelerator(gobj()); 
+  gtk_action_connect_accelerator(gobj());
 }
 
 void Action::disconnect_accelerator()
 {
-gtk_action_disconnect_accelerator(gobj()); 
+  gtk_action_disconnect_accelerator(gobj());
 }
 
 Glib::ustring Action::get_accel_path() const
@@ -480,22 +445,22 @@ Glib::ustring Action::get_accel_path() const
 
 void Action::set_accel_path(const Glib::ustring& accel_path)
 {
-gtk_action_set_accel_path(gobj(), accel_path.c_str()); 
+  gtk_action_set_accel_path(gobj(), accel_path.c_str());
 }
 
 void Action::set_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
 {
-gtk_action_set_accel_group(gobj(), Glib::unwrap(accel_group)); 
+  gtk_action_set_accel_group(gobj(), Glib::unwrap(accel_group));
 }
 
 void Action::block_activate_from(Widget& proxy)
 {
-gtk_action_block_activate_from(gobj(), (proxy).gobj()); 
+  gtk_action_block_activate_from(gobj(), (proxy).gobj());
 }
 
 void Action::unblock_activate_from(Widget& proxy)
 {
-gtk_action_unblock_activate_from(gobj(), (proxy).gobj()); 
+  gtk_action_unblock_activate_from(gobj(), (proxy).gobj());
 }
 
 
@@ -505,155 +470,112 @@ Glib::SignalProxy0< void > Action::signal_activate()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Action::property_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Action::property_short_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "short-label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_short_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "short-label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Action::property_tooltip() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "tooltip");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Action::property_tooltip() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "tooltip");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<StockID> Action::property_stock_id() 
 {
   return Glib::PropertyProxy<StockID>(this, "stock-id");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<StockID> Action::property_stock_id() const
 {
   return Glib::PropertyProxy_ReadOnly<StockID>(this, "stock-id");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Action::property_visible_horizontal() 
 {
   return Glib::PropertyProxy<bool>(this, "visible-horizontal");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Action::property_visible_horizontal() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-horizontal");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Action::property_visible_vertical() 
 {
   return Glib::PropertyProxy<bool>(this, "visible-vertical");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Action::property_visible_vertical() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-vertical");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Action::property_is_important() 
 {
   return Glib::PropertyProxy<bool>(this, "is-important");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Action::property_is_important() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "is-important");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Action::property_hide_if_empty() 
 {
   return Glib::PropertyProxy<bool>(this, "hide-if-empty");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Action::property_hide_if_empty() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "hide-if-empty");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Action::property_sensitive() 
 {
   return Glib::PropertyProxy<bool>(this, "sensitive");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Action::property_sensitive() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "sensitive");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Action::property_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Action::property_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Action::on_activate()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -663,9 +585,8 @@ void Gtk::Action::on_activate()
   if(base && base->activate)
     (*base->activate)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 Widget* Gtk::Action::create_menu_item_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -678,6 +599,7 @@ Widget* Gtk::Action::create_menu_item_vfunc()
   typedef Widget* RType;
   return RType();
 }
+
 Widget* Gtk::Action::create_tool_item_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -690,6 +612,7 @@ Widget* Gtk::Action::create_tool_item_vfunc()
   typedef Widget* RType;
   return RType();
 }
+
 void Gtk::Action::connect_proxy_vfunc(Widget* proxy) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -699,6 +622,7 @@ void Gtk::Action::connect_proxy_vfunc(Widget* proxy)
   if(base && base->connect_proxy)
     (*base->connect_proxy)(gobj(),(GtkWidget*)Glib::unwrap(proxy));
 }
+
 void Gtk::Action::disconnect_proxy_vfunc(Widget* proxy) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -708,7 +632,6 @@ void Gtk::Action::disconnect_proxy_vfunc(Widget* proxy)
   if(base && base->disconnect_proxy)
     (*base->disconnect_proxy)(gobj(),(GtkWidget*)Glib::unwrap(proxy));
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/action.h b/libs/gtkmm2/gtk/gtkmm/action.h
index f1ba555efa..6c319c769a 100644
--- a/libs/gtkmm2/gtk/gtkmm/action.h
+++ b/libs/gtkmm2/gtk/gtkmm/action.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ACTION_H
 #define _GTKMM_ACTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -28,7 +27,7 @@
 #include <gtkmm/widget.h>
 #include <gtkmm/accelgroup.h>
 #include <gtkmm/stockid.h>
-
+ 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 typedef struct _GtkAction GtkAction;
@@ -107,7 +106,7 @@ public:
    * @return The name of the action. The string belongs to GTK+ and should not
    * be freed.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_name() const;
 
@@ -116,7 +115,7 @@ public:
    * @return <tt>true</tt> if the action and its associated action group 
    * are both sensitive.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool is_sensitive() const;
   
@@ -125,10 +124,11 @@ public:
    * for that.
    * @return <tt>true</tt> if the action itself is sensitive.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_sensitive() const;
 
+   //TODO: Just wrap gtk_action_set_sensitive() when they put it in GTK+.
    void set_tooltip(const Glib::ustring& tooltip);
 
   
@@ -137,17 +137,17 @@ public:
    * is_sensitive() 
    * for that.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param sensitive <tt>true</tt> to make the action sensitive.
    */
   void set_sensitive(bool sensitive = true);
-
+  
   
   /** Returns whether the action is effectively visible.
    * @return <tt>true</tt> if the action and its associated action group 
    * are both visible.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool is_visible() const;
   
@@ -156,7 +156,7 @@ public:
    * for that.
    * @return <tt>true</tt> if the action itself is visible.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_visible() const;
   
@@ -165,7 +165,7 @@ public:
    * is_visible() 
    * for that.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param visible <tt>true</tt> to make the action visible.
    */
   void set_visible(bool visible = true);
@@ -177,7 +177,7 @@ public:
    * 
    * It can also be used to manually activate an action.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void activate();
   
@@ -186,21 +186,21 @@ public:
    * @param icon_size The size of the icon that should be created.
    * @return A widget that displays the icon for this action.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Image* create_icon(IconSize icon_size);
   
   /** Creates a menu item widget that proxies for the given action.
    * @return A menu item connected to the action.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   MenuItem* create_menu_item();
   
   /** Creates a toolbar item widget that proxies for the given action.
    * @return A toolbar item connected to the action.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   ToolItem* create_tool_item();
   
@@ -212,7 +212,7 @@ public:
    * If the widget is already connected to an action, it is disconnected
    * first.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param proxy The proxy widget.
    */
   void connect_proxy(Widget& proxy);
@@ -220,17 +220,16 @@ public:
   /** Disconnects a proxy widget from an action.  
    * Does <em>not</em> destroy the widget, however.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param proxy The proxy widget.
    */
   void disconnect_proxy(Widget& proxy);
-
   
   /** Returns the proxy widgets for an action.
    * @return A G::SList of proxy widgets. The list is owned by the action and
    * must not be modified.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle<Widget*> get_proxies();
   
@@ -238,10 +237,9 @@ public:
    * @return A G::SList of proxy widgets. The list is owned by the action and
    * must not be modified.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle<const Widget*> get_proxies() const;
-
   
   /** Installs the accelerator for @a action  if @a action  has an
    * accel path and group. See set_accel_path() and 
@@ -252,20 +250,20 @@ public:
    * function has been called and doesn't remove the accelerator until
    * disconnect_accelerator() has been called as many times.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void connect_accelerator();
   
   /** Undoes the effect of one call to connect_accelerator().
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void disconnect_accelerator();
   
   
   /** Returns the accel path for this action.  
    * 
-   * @newin2p6
+   * Since: 2.6
    * @return The accel path for this action, or <tt>0</tt>
    * if none is set. The returned string is owned by GTK+
    * and must not be freed or modified.
@@ -275,13 +273,6 @@ public:
   /// For instance, void on_activate();
   typedef sigc::slot<void> SlotActivate;
   
-  /** The "activate" signal is emitted when the action is activated.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %activate()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_activate();
 
@@ -292,7 +283,7 @@ public:
    * with the action will have this accel path, so that their
    * accelerators are consistent.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param accel_path The accelerator path.
    */
   void set_accel_path(const Glib::ustring& accel_path);
@@ -300,33 +291,28 @@ public:
   /** Sets the Gtk::AccelGroup in which the accelerator for this action
    * will be installed.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param accel_group A Gtk::AccelGroup or <tt>0</tt>.
    */
   void set_accel_group(const Glib::RefPtr<AccelGroup>& accel_group);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A unique name for the action.
+  /** A unique name for the action.
    *
    * 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_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The label used for menu items and buttons that activate this action.
+  /** The label used for menu items and buttons that activate this action.
    *
    * 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_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The label used for menu items and buttons that activate this action.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -334,19 +320,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A shorter label that may be used on toolbar buttons.
+  /** A shorter label that may be used on toolbar buttons.
    *
    * 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_short_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A shorter label that may be used on toolbar buttons.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -354,19 +336,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_short_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A tooltip for this action.
+  /** A tooltip for this action.
    *
    * 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_tooltip() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A tooltip for this action.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -374,19 +352,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_tooltip() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The stock icon displayed in widgets representing this action.
+  /** The stock icon displayed in widgets representing this action.
    *
    * 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<StockID> property_stock_id() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The stock icon displayed in widgets representing this action.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -394,19 +368,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<StockID> property_stock_id() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+  /** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
    *
    * 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_horizontal() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -414,19 +384,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible_horizontal() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+  /** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
    *
    * 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_vertical() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -434,19 +400,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible_vertical() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the action is considered important. When TRUE
+  /** Whether the action is considered important. When TRUE
    *
    * 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_is_important() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the action is considered important. When TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -454,19 +416,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_is_important() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** When TRUE
+  /** When TRUE
    *
    * 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_hide_if_empty() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** When TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -474,19 +432,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_hide_if_empty() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the action is enabled.
+  /** Whether the action is enabled.
    *
    * 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_sensitive() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the action is enabled.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -494,19 +448,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_sensitive() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the action is visible.
+  /** Whether the action is 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<bool> property_visible() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the action is visible.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -514,7 +464,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -526,7 +475,7 @@ protected:
    * 
    * This function is intended for use by action implementations.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param proxy A proxy widget.
    */
   void block_activate_from(Widget& proxy);
@@ -537,7 +486,7 @@ protected:
    * 
    * This function is intended for use by action implementations.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param proxy A proxy widget.
    */
   void unblock_activate_from(Widget& proxy);
@@ -545,39 +494,22 @@ protected:
 
 protected: 
   //Widget-creation routines:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Widget* create_menu_item_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Widget* create_tool_item_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void connect_proxy_vfunc(Widget* proxy);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void disconnect_proxy_vfunc(Widget* proxy);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual Widget* create_menu_item_vfunc();
+    virtual Widget* create_tool_item_vfunc();
+    virtual void connect_proxy_vfunc(Widget* proxy);
+    virtual void disconnect_proxy_vfunc(Widget* proxy);
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_activate();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/actiongroup.cc b/libs/gtkmm2/gtk/gtkmm/actiongroup.cc
index 55c77ac7e8..d539b9ab5e 100644
--- a/libs/gtkmm2/gtk/gtkmm/actiongroup.cc
+++ b/libs/gtkmm2/gtk/gtkmm/actiongroup.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/actiongroup.h>
 #include <gtkmm/private/actiongroup_p.h>
 
@@ -54,16 +53,9 @@ void ActionGroup::add(const Glib::RefPtr<Action>& action, const AccelKey& accel_
     if(accel_path.empty())
     {
       //Copied from the gtk_action_group_add_action_with_accel() implementation:
-      
-      gchar* action_name = 0;
-      g_object_get(G_OBJECT(action->gobj()), "name", &action_name, NULL); /* Using 0 instead of NULL gives a warning about a missing sentinel. Possibly it must be (void*)0. */
-      if(action_name)
-      { 
-        accel_path =  "<Actions>/" + get_name() + "/" + action_name;
-        g_free(action_name);
-      }
+      accel_path =  "<Actions>/" + get_name() + "/" + action->property_name();
     }
-
+    
     AccelMap::add_entry(accel_path, key, mod);
 
     action->set_accel_path(accel_path);
@@ -117,8 +109,7 @@ void ActionGroup::add(const Glib::RefPtr<Action>& action, const AccelKey& accel_
 namespace
 {
 
-
-static void ActionGroup_signal_connect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
+void ActionGroup_signal_connect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
@@ -126,25 +117,21 @@ static void ActionGroup_signal_connect_proxy_callback(GtkActionGroup* self, GtkA
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ActionGroup_signal_connect_proxy_info =
+const Glib::SignalProxyInfo ActionGroup_signal_connect_proxy_info =
 {
   "connect_proxy",
   (GCallback) &ActionGroup_signal_connect_proxy_callback,
@@ -152,7 +139,7 @@ static const Glib::SignalProxyInfo ActionGroup_signal_connect_proxy_info =
 };
 
 
-static void ActionGroup_signal_disconnect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
+void ActionGroup_signal_disconnect_proxy_callback(GtkActionGroup* self, GtkAction* p0,GtkWidget* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
@@ -160,25 +147,21 @@ static void ActionGroup_signal_disconnect_proxy_callback(GtkActionGroup* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ActionGroup_signal_disconnect_proxy_info =
+const Glib::SignalProxyInfo ActionGroup_signal_disconnect_proxy_info =
 {
   "disconnect_proxy",
   (GCallback) &ActionGroup_signal_disconnect_proxy_callback,
@@ -186,7 +169,7 @@ static const Glib::SignalProxyInfo ActionGroup_signal_disconnect_proxy_info =
 };
 
 
-static void ActionGroup_signal_pre_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
+void ActionGroup_signal_pre_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
@@ -194,24 +177,20 @@ static void ActionGroup_signal_pre_activate_callback(GtkActionGroup* self, GtkAc
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ActionGroup_signal_pre_activate_info =
+const Glib::SignalProxyInfo ActionGroup_signal_pre_activate_info =
 {
   "pre_activate",
   (GCallback) &ActionGroup_signal_pre_activate_callback,
@@ -219,7 +198,7 @@ static const Glib::SignalProxyInfo ActionGroup_signal_pre_activate_info =
 };
 
 
-static void ActionGroup_signal_post_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
+void ActionGroup_signal_post_activate_callback(GtkActionGroup* self, GtkAction* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
@@ -227,31 +206,26 @@ static void ActionGroup_signal_post_activate_callback(GtkActionGroup* self, GtkA
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ActionGroup_signal_post_activate_info =
+const Glib::SignalProxyInfo ActionGroup_signal_post_activate_info =
 {
   "post_activate",
   (GCallback) &ActionGroup_signal_post_activate_callback,
   (GCallback) &ActionGroup_signal_post_activate_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -298,19 +272,8 @@ void ActionGroup_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ActionGroup_Class::wrap_new(GObject* object)
 {
@@ -376,7 +339,7 @@ bool ActionGroup::get_sensitive() const
 
 void ActionGroup::set_sensitive(bool sensitive)
 {
-gtk_action_group_set_sensitive(gobj(), static_cast<int>(sensitive)); 
+  gtk_action_group_set_sensitive(gobj(), static_cast<int>(sensitive));
 }
 
 bool ActionGroup::get_visible() const
@@ -386,22 +349,27 @@ bool ActionGroup::get_visible() const
 
 void ActionGroup::set_visible(bool visible)
 {
-gtk_action_group_set_visible(gobj(), static_cast<int>(visible)); 
+  gtk_action_group_set_visible(gobj(), static_cast<int>(visible));
 }
 
 Glib::RefPtr<Action> ActionGroup::get_action(const Glib::ustring& action_name)
 {
 
   Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_action_group_get_action(gobj(), action_name.c_str()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Action> ActionGroup::get_action(const Glib::ustring& action_name) const
 {
-  return const_cast<ActionGroup*>(this)->get_action(action_name);
+
+  Glib::RefPtr<const Action> retvalue = Glib::wrap(gtk_action_group_get_action(const_cast<GtkActionGroup*>(gobj()), action_name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::ListHandle< Glib::RefPtr<Action> > ActionGroup::get_actions()
@@ -416,7 +384,7 @@ Glib::ListHandle< Glib::RefPtr<const Action> > ActionGroup::get_actions() const
 
 void ActionGroup::remove(const Glib::RefPtr<Action>& action)
 {
-gtk_action_group_remove_action(gobj(), Glib::unwrap(action)); 
+  gtk_action_group_remove_action(gobj(), Glib::unwrap(action));
 }
 
 Glib::ustring ActionGroup::translate_string(const Glib::ustring& str) const
@@ -430,32 +398,22 @@ Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > ActionGroup::sign
   return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &ActionGroup_signal_connect_proxy_info);
 }
 
-
 Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > ActionGroup::signal_disconnect_proxy()
 {
   return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &ActionGroup_signal_disconnect_proxy_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > ActionGroup::signal_pre_activate()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &ActionGroup_signal_pre_activate_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > ActionGroup::signal_post_activate()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &ActionGroup_signal_post_activate_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/actiongroup.h b/libs/gtkmm2/gtk/gtkmm/actiongroup.h
index 4416d6102e..8db2b42e80 100644
--- a/libs/gtkmm2/gtk/gtkmm/actiongroup.h
+++ b/libs/gtkmm2/gtk/gtkmm/actiongroup.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ACTIONGROUP_H
 #define _GTKMM_ACTIONGROUP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -98,7 +97,7 @@ public:
   /** Gets the name of the action group.
    * @return The name of the action group.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_name() const;
 
@@ -109,13 +108,13 @@ public:
    * is sensitive.
    * @return <tt>true</tt> if the group is sensitive.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_sensitive() const;
   
   /** Changes the sensitivity of @a action_group 
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param sensitive New sensitivity.
    */
   void set_sensitive(bool sensitive = true);
@@ -126,13 +125,13 @@ public:
    * is visible.
    * @return <tt>true</tt> if the group is visible.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_visible() const;
   
   /** Changes the visible of @a action_group .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param visible New visiblity.
    */
   void set_visible(bool visible = true);
@@ -142,7 +141,7 @@ public:
    * @param action_name The name of the action.
    * @return The action, or <tt>0</tt> if no action by that name exists
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<Action> get_action(const Glib::ustring& action_name);
   
@@ -150,7 +149,7 @@ public:
    * @param action_name The name of the action.
    * @return The action, or <tt>0</tt> if no action by that name exists
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const Action> get_action(const Glib::ustring& action_name) const;
 
@@ -158,14 +157,14 @@ public:
   /** Lists the actions in the action group.
    * @return An allocated list of the action objects in the action group
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ListHandle< Glib::RefPtr<Action> > get_actions();
   
   /** Lists the actions in the action group.
    * @return An allocated list of the action objects in the action group
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ListHandle< Glib::RefPtr<const Action> > get_actions() const;
     
@@ -186,7 +185,7 @@ public:
   
   /** Removes an action object from the action group.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param action An action.
    */
   void remove(const Glib::RefPtr<Action>& action);
@@ -198,7 +197,7 @@ public:
    * @param string A string.
    * @return The translation of @a string 
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring translate_string(const Glib::ustring& str) const;
   
@@ -208,80 +207,15 @@ public:
   //These are also just C convenience methods that are useless unless you are using the other convenience methods:
   
 
-  /** The connect_proxy signal is emitted after connecting a proxy to 
-   * an action in the group. Note that the proxy may have been connected 
-   * to a different action before.
-   *
-   * This is intended for simple customizations for which a custom action
-   * class would be too clumsy, e.g. showing tooltips for menuitems in the
-   * statusbar.
-   *
-   * UIManager proxies the signal and provides global notification 
-   * just before any action is connected to a proxy, which is probably more
-   * convenient to use.
-   *
-   * @param action the action
-   * @param proxy the proxy
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %connect_proxy(const Glib::RefPtr<Action>& action, Widget* proxy)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_connect_proxy();
 
   
-  /** The disconnect_proxy signal is emitted after disconnecting a proxy 
-   * from an action in the group. 
-   *
-   * UIManager proxies the signal and provides global notification 
-   * just before any action is connected to a proxy, which is probably more
-   * convenient to use.
-   *
-   * @param action the action
-   * @param proxy the proxy
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %disconnect_proxy(const Glib::RefPtr<Action>& action, Widget* proxy)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_disconnect_proxy();
-
-  
-  /** The pre_activate signal is emitted just before the @action in the
-   * action_group is activated
-   *
-   * This is intended for UIManager to proxy the signal and provide global
-   * notification just before any action is activated.
-   *
-   * @action the action
-   */          
+             
   
-/**
-   * @par Prototype:
-   * <tt>void %pre_activate(const Glib::RefPtr<Action>& action)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_pre_activate();
-
-  
-  /** The post_activate signal is emitted just after the @action in the
-   * @action_group is activated
-   *
-   * This is intended for UIManager to proxy the signal and provide global
-   * notification just after any action is activated.
-   *
-   * @param action the action
-   */ 
+ 
   
-/**
-   * @par Prototype:
-   * <tt>void %post_activate(const Glib::RefPtr<Action>& action)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_post_activate();
  
 
@@ -289,17 +223,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/adjustment.cc b/libs/gtkmm2/gtk/gtkmm/adjustment.cc
index 8be2188291..10b2e8815f 100644
--- a/libs/gtkmm2/gtk/gtkmm/adjustment.cc
+++ b/libs/gtkmm2/gtk/gtkmm/adjustment.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/adjustment.h>
 #include <gtkmm/private/adjustment_p.h>
 
@@ -30,13 +29,22 @@
 namespace Gtk
 {
 
-//This is hand-coded so we can change the sequence of properties.
-//If we don't do this then the value is restricted to the initial values, ignoring the specified boundaries:
-Adjustment::Adjustment(double value, double lower, double upper, double step_increment, double page_increment, double page_size)
+Adjustment::Adjustment(double value,
+      	               double lower, double upper,
+      	               double step_increment, double page_increment,
+      	               double page_size)
 :
   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Object(Glib::ConstructParams(adjustment_class_.init(), "lower",lower,"upper",upper,"step_increment",step_increment,"page_increment",page_increment,"page_size",page_size,"value",value, (char*) 0))
+  Gtk::Object(Glib::ConstructParams(adjustment_class_.init(), (char*) 0))
 {
+  gobj()->lower = lower;
+  gobj()->upper = upper;
+  gobj()->step_increment = step_increment;
+  gobj()->page_increment = page_increment;
+  gobj()->page_size = page_size;
+  changed();
+
+  set_value(value);
 }
 
 void Adjustment::set_lower(double lower)
@@ -75,8 +83,7 @@ void Adjustment::set_page_size(double size)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Adjustment_signal_changed_info =
+const Glib::SignalProxyInfo Adjustment_signal_changed_info =
 {
   "changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -84,14 +91,13 @@ static const Glib::SignalProxyInfo Adjustment_signal_changed_info =
 };
 
 
-static const Glib::SignalProxyInfo Adjustment_signal_value_changed_info =
+const Glib::SignalProxyInfo Adjustment_signal_value_changed_info =
 {
   "value_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -136,19 +142,11 @@ void Adjustment_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->changed = &changed_callback;
   klass->value_changed = &value_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Adjustment_Class::changed_callback(GtkAdjustment* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -161,19 +159,15 @@ void Adjustment_Class::changed_callback(GtkAdjustment* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -186,6 +180,7 @@ void Adjustment_Class::changed_callback(GtkAdjustment* self)
       (*base->changed)(self);
   }
 }
+
 void Adjustment_Class::value_changed_callback(GtkAdjustment* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -198,19 +193,15 @@ void Adjustment_Class::value_changed_callback(GtkAdjustment* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_value_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -223,7 +214,6 @@ void Adjustment_Class::value_changed_callback(GtkAdjustment* self)
       (*base->value_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Adjustment_Class::wrap_new(GObject* o)
@@ -267,22 +257,22 @@ GType Adjustment::get_base_type()
 
 void Adjustment::changed()
 {
-gtk_adjustment_changed(gobj()); 
+  gtk_adjustment_changed(gobj());
 }
 
 void Adjustment::value_changed()
 {
-gtk_adjustment_value_changed(gobj()); 
+  gtk_adjustment_value_changed(gobj());
 }
 
 void Adjustment::clamp_page(double lower, double upper)
 {
-gtk_adjustment_clamp_page(gobj(), lower, upper); 
+  gtk_adjustment_clamp_page(gobj(), lower, upper);
 }
 
 void Adjustment::set_value(double value)
 {
-gtk_adjustment_set_value(gobj(), value); 
+  gtk_adjustment_set_value(gobj(), value);
 }
 
 double Adjustment::get_value() const
@@ -290,45 +280,43 @@ double Adjustment::get_value() const
   return gtk_adjustment_get_value(const_cast<GtkAdjustment*>(gobj()));
 }
 
- double Adjustment::get_lower() const
+double Adjustment::get_lower() const
 {
   return gobj()->lower;
 }
- 
- double Adjustment::get_upper() const
+
+double Adjustment::get_upper() const
 {
   return gobj()->upper;
 }
- 
- double Adjustment::get_step_increment() const
+
+double Adjustment::get_step_increment() const
 {
   return gobj()->step_increment;
 }
- 
- double Adjustment::get_page_increment() const
+
+double Adjustment::get_page_increment() const
 {
   return gobj()->page_increment;
 }
- 
- double Adjustment::get_page_size() const
+
+double Adjustment::get_page_size() const
 {
   return gobj()->page_size;
 }
- 
+
 
 Glib::SignalProxy0< void > Adjustment::signal_changed()
 {
   return Glib::SignalProxy0< void >(this, &Adjustment_signal_changed_info);
 }
 
-
 Glib::SignalProxy0< void > Adjustment::signal_value_changed()
 {
   return Glib::SignalProxy0< void >(this, &Adjustment_signal_value_changed_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Adjustment::on_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -338,6 +326,7 @@ void Gtk::Adjustment::on_changed()
   if(base && base->changed)
     (*base->changed)(gobj());
 }
+
 void Gtk::Adjustment::on_value_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -347,10 +336,6 @@ void Gtk::Adjustment::on_value_changed()
   if(base && base->value_changed)
     (*base->value_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/adjustment.h b/libs/gtkmm2/gtk/gtkmm/adjustment.h
index 6a5a347552..2c45297cb4 100644
--- a/libs/gtkmm2/gtk/gtkmm/adjustment.h
+++ b/libs/gtkmm2/gtk/gtkmm/adjustment.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ADJUSTMENT_H
 #define _GTKMM_ADJUSTMENT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -101,19 +100,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_changed();
   virtual void on_value_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -132,9 +125,12 @@ public:
    * @param page_increment The page increment
    * @param page_size The page size
    */
-  Adjustment(double value, double lower, double upper, double step_increment = 1, double page_increment = 10, double page_size = 0);
-  
+  Adjustment(double value,
+      	     double lower,  double upper,
+      	     double step_increment = 1, double page_increment = 10,
+      	     double page_size = 0);
   
+
   /** Emits a "changed" signal from the Adjustment.  This is typically called by the owner of the Adjustment after it has changed any of the Adjustment fields other than the value.
    */
   void changed();
@@ -166,28 +162,28 @@ public:
   /** Retrieve the @a lower member variable.
    * @return The current value of @a lower.
    */
-   double get_lower() const;
- 
+  double get_lower() const;
+
   /** Retrieve the @a upper member variable.
    * @return The current value of @a upper.
    */
-   double get_upper() const;
- 
+  double get_upper() const;
+
   /** Retrieve the @a step_increment variable.
    * @return The current value of @a step_increment.
    */
-   double get_step_increment() const;
- 
+  double get_step_increment() const;
+
   /** Retrieve the @a page_increment variable.
    * @return The current value of @a page_increment.
    */
-   double get_page_increment() const;
- 
+  double get_page_increment() const;
+
   /** Retrieve the @a page_size variable.
    * @return The current value of @a page_size.
    */
-   double get_page_size() const;
- 
+  double get_page_size() const;
+
   // TODO: This section needs changing. We must be able to set more at a time,
   // emitting "changed" signal only once.
   /** Sets the @a lower member variable
@@ -216,19 +212,9 @@ public:
   void set_page_size(double size);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %value_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_value_changed();
 
 
@@ -245,8 +231,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Adjustment* wrap(GtkAdjustment* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ADJUSTMENT_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/alignment.cc b/libs/gtkmm2/gtk/gtkmm/alignment.cc
index 59555cc32a..56f5c58726 100644
--- a/libs/gtkmm2/gtk/gtkmm/alignment.cc
+++ b/libs/gtkmm2/gtk/gtkmm/alignment.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/alignment.h>
 #include <gtkmm/private/alignment_p.h>
 
@@ -81,19 +80,8 @@ void Alignment_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Alignment_Class::wrap_new(GObject* o)
 {
@@ -150,143 +138,104 @@ Alignment::Alignment(AlignmentEnum xalign, AlignmentEnum yalign, float xscale, f
 
 void Alignment::set(float xalign, float yalign, float xscale, float yscale)
 {
-gtk_alignment_set(gobj(), xalign, yalign, xscale, yscale); 
+  gtk_alignment_set(gobj(), xalign, yalign, xscale, yscale);
 }
 
 void Alignment::set(AlignmentEnum xalign, AlignmentEnum yalign, float xscale, float yscale)
 {
-gtk_alignment_set(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign), xscale, yscale); 
+  gtk_alignment_set(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign), xscale, yscale);
 }
 
 void Alignment::set_padding(guint padding_top, guint padding_bottom, guint padding_left, guint padding_right)
 {
-gtk_alignment_set_padding(gobj(), padding_top, padding_bottom, padding_left, padding_right); 
+  gtk_alignment_set_padding(gobj(), padding_top, padding_bottom, padding_left, padding_right);
 }
 
 void Alignment::get_padding(guint& padding_top, guint& padding_bottom, guint& padding_left, guint& padding_right)
 {
-gtk_alignment_get_padding(gobj(), &(padding_top), &(padding_bottom), &(padding_left), &(padding_right)); 
+  gtk_alignment_get_padding(gobj(), &(padding_top), &(padding_bottom), &(padding_left), &(padding_right));
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Alignment::property_xalign() 
 {
   return Glib::PropertyProxy<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Alignment::property_xalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Alignment::property_yalign() 
 {
   return Glib::PropertyProxy<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Alignment::property_yalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Alignment::property_xscale() 
 {
   return Glib::PropertyProxy<float>(this, "xscale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Alignment::property_xscale() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "xscale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Alignment::property_yscale() 
 {
   return Glib::PropertyProxy<float>(this, "yscale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Alignment::property_yscale() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "yscale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Alignment::property_top_padding() 
 {
   return Glib::PropertyProxy<guint>(this, "top-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Alignment::property_top_padding() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "top-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Alignment::property_bottom_padding() 
 {
   return Glib::PropertyProxy<guint>(this, "bottom-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Alignment::property_bottom_padding() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "bottom-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Alignment::property_left_padding() 
 {
   return Glib::PropertyProxy<guint>(this, "left-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Alignment::property_left_padding() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "left-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Alignment::property_right_padding() 
 {
   return Glib::PropertyProxy<guint>(this, "right-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Alignment::property_right_padding() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "right-padding");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/alignment.h b/libs/gtkmm2/gtk/gtkmm/alignment.h
index 265d34709f..98130b9e2d 100644
--- a/libs/gtkmm2/gtk/gtkmm/alignment.h
+++ b/libs/gtkmm2/gtk/gtkmm/alignment.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ALIGNMENT_H
 #define _GTKMM_ALIGNMENT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -100,17 +99,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -157,7 +150,7 @@ public:
    * this can be used to indent the child widget towards the right by adding
    * padding on the left.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param padding_top The padding at the top of the widget.
    * @param padding_bottom The padding at the bottom of the widget.
    * @param padding_left The padding at the left of the widget.
@@ -168,7 +161,7 @@ public:
   /** Gets the padding on the different sides of the widget.
    * See set_padding().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param padding_top Location to store the padding for the top of the widget, or <tt>0</tt>.
    * @param padding_bottom Location to store the padding for the bottom of the widget, or <tt>0</tt>.
    * @param padding_left Location to store the padding for the left of the widget, or <tt>0</tt>.
@@ -176,17 +169,14 @@ public:
    */
   void get_padding(guint& padding_top, guint& padding_bottom, guint& padding_left, guint& padding_right);
               
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Horizontal position of child in available space. 0.0 is left aligned
+  /** Horizontal position of child in available space. 0.0 is left aligned
    *
    * 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<float> property_xalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Horizontal position of child in available space. 0.0 is left aligned
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -194,19 +184,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Vertical position of child in available space. 0.0 is top aligned
+  /** Vertical position of child in available space. 0.0 is top aligned
    *
    * 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<float> property_yalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Vertical position of child in available space. 0.0 is top aligned
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -214,19 +200,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If available horizontal space is bigger than needed for the child
+  /** If available horizontal space is bigger than needed for the child
    *
    * 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<float> property_xscale() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If available horizontal space is bigger than needed for the child
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -234,19 +216,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_xscale() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If available vertical space is bigger than needed for the child
+  /** If available vertical space is bigger than needed for the child
    *
    * 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<float> property_yscale() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If available vertical space is bigger than needed for the child
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -254,21 +232,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_yscale() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   //New in GTK+ 2.4
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The padding to insert at the top of the widget.
+  /** The padding to insert at the top of the 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<guint> property_top_padding() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The padding to insert at the top of the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -276,19 +250,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_top_padding() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The padding to insert at the bottom of the widget.
+  /** The padding to insert at the bottom of the 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<guint> property_bottom_padding() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The padding to insert at the bottom of the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -296,19 +266,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_bottom_padding() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The padding to insert at the left of the widget.
+  /** The padding to insert at the left of the 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<guint> property_left_padding() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The padding to insert at the left of the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -316,19 +282,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_left_padding() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The padding to insert at the right of the widget.
+  /** The padding to insert at the right of the 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<guint> property_right_padding() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The padding to insert at the right of the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -336,7 +298,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_right_padding() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -352,8 +313,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Alignment* wrap(GtkAlignment* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ALIGNMENT_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/arrow.cc b/libs/gtkmm2/gtk/gtkmm/arrow.cc
index a4a4f5b24f..681847cc02 100644
--- a/libs/gtkmm2/gtk/gtkmm/arrow.cc
+++ b/libs/gtkmm2/gtk/gtkmm/arrow.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/arrow.h>
 #include <gtkmm/private/arrow_p.h>
 
@@ -97,19 +96,8 @@ void Arrow_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Arrow_Class::wrap_new(GObject* o)
 {
@@ -159,44 +147,29 @@ Arrow::Arrow(ArrowType arrow_type, ShadowType shadow_type)
 
 void Arrow::set(ArrowType arrow_type, ShadowType shadow_type)
 {
-gtk_arrow_set(gobj(), ((GtkArrowType)(arrow_type)), ((GtkShadowType)(shadow_type))); 
+  gtk_arrow_set(gobj(), ((GtkArrowType)(arrow_type)), ((GtkShadowType)(shadow_type)));
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ArrowType> Arrow::property_arrow_type() 
 {
   return Glib::PropertyProxy<ArrowType>(this, "arrow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ArrowType> Arrow::property_arrow_type() const
 {
   return Glib::PropertyProxy_ReadOnly<ArrowType>(this, "arrow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ShadowType> Arrow::property_shadow_type() 
 {
   return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ShadowType> Arrow::property_shadow_type() const
 {
   return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/arrow.h b/libs/gtkmm2/gtk/gtkmm/arrow.h
index 8a6e3e15c1..f34a744d3e 100644
--- a/libs/gtkmm2/gtk/gtkmm/arrow.h
+++ b/libs/gtkmm2/gtk/gtkmm/arrow.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ARROW_H
 #define _GTKMM_ARROW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -97,17 +96,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -132,17 +125,14 @@ public:
    */
   void set(ArrowType arrow_type, ShadowType shadow_type);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The direction the arrow should point.
+  /** The direction the arrow should point.
    *
    * 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<ArrowType> property_arrow_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The direction the arrow should point.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -150,19 +140,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ArrowType> property_arrow_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Appearance of the shadow surrounding the arrow.
+  /** Appearance of the shadow surrounding the arrow.
    *
    * 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<ShadowType> property_shadow_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Appearance of the shadow surrounding the arrow.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -170,7 +156,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -187,8 +172,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Arrow* wrap(GtkArrow* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ARROW_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/aspectframe.cc b/libs/gtkmm2/gtk/gtkmm/aspectframe.cc
index 84d97d7df3..faf6a94286 100644
--- a/libs/gtkmm2/gtk/gtkmm/aspectframe.cc
+++ b/libs/gtkmm2/gtk/gtkmm/aspectframe.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/aspectframe.h>
 #include <gtkmm/private/aspectframe_p.h>
 
@@ -28,6 +27,7 @@
 
 #include <gtk/gtkaspectframe.h>
 
+
 namespace
 {
 } // anonymous namespace
@@ -74,19 +74,8 @@ void AspectFrame_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* AspectFrame_Class::wrap_new(GObject* o)
 {
@@ -143,77 +132,54 @@ AspectFrame::AspectFrame(const Glib::ustring& label, float xalign, float yalign,
 
 void AspectFrame::set(float xalign, float yalign, float ratio, bool obey_child)
 {
-gtk_aspect_frame_set(gobj(), xalign, yalign, ratio, static_cast<int>(obey_child)); 
+  gtk_aspect_frame_set(gobj(), xalign, yalign, ratio, static_cast<int>(obey_child));
 }
 
 void AspectFrame::set(AlignmentEnum xalign, AlignmentEnum yalign, float ratio, bool obey_child)
 {
-gtk_aspect_frame_set(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign), ratio, static_cast<int>(obey_child)); 
+  gtk_aspect_frame_set(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign), ratio, static_cast<int>(obey_child));
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> AspectFrame::property_xalign() 
 {
   return Glib::PropertyProxy<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> AspectFrame::property_xalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> AspectFrame::property_yalign() 
 {
   return Glib::PropertyProxy<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> AspectFrame::property_yalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> AspectFrame::property_ratio() 
 {
   return Glib::PropertyProxy<float>(this, "ratio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> AspectFrame::property_ratio() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "ratio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> AspectFrame::property_obey_child() 
 {
   return Glib::PropertyProxy<bool>(this, "obey-child");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> AspectFrame::property_obey_child() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "obey-child");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/aspectframe.h b/libs/gtkmm2/gtk/gtkmm/aspectframe.h
index 3ec9dffed9..4687417211 100644
--- a/libs/gtkmm2/gtk/gtkmm/aspectframe.h
+++ b/libs/gtkmm2/gtk/gtkmm/aspectframe.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ASPECTFRAME_H
 #define _GTKMM_ASPECTFRAME_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,17 +95,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -166,17 +159,14 @@ public:
   
   void set(AlignmentEnum xalign, AlignmentEnum yalign, float ratio, bool obey_child = true);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** X alignment of the child.
+  /** X alignment of the child.
    *
    * 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<float> property_xalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** X alignment of the child.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -184,19 +174,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Y alignment of the child.
+  /** Y alignment of the child.
    *
    * 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<float> property_yalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Y alignment of the child.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -204,19 +190,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Aspect ratio if obey_child is FALSE.
+  /** Aspect ratio if obey_child is FALSE.
    *
    * 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<float> property_ratio() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Aspect ratio if obey_child is FALSE.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -224,19 +206,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_ratio() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Force aspect ratio to match that of the frame's child.
+  /** Force aspect ratio to match that of the frame's child.
    *
    * 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_obey_child() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Force aspect ratio to match that of the frame's child.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -244,7 +222,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_obey_child() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -260,8 +237,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::AspectFrame* wrap(GtkAspectFrame* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ASPECTFRAME_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/assistant.cc b/libs/gtkmm2/gtk/gtkmm/assistant.cc
deleted file mode 100644
index c608e7a8c8..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/assistant.cc
+++ /dev/null
@@ -1,586 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/assistant.h>
-#include <gtkmm/private/assistant_p.h>
-
-// -*- c++ -*-
-/* $Id: assistant.ccg,v 1.3 2006/05/11 11:40:24 murrayc Exp $ */
-
-/* 
- *
- * Copyright 2006 The gtkmm 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 <gtk/gtkassistant.h>
-#include <gtk/gtklabel.h>
-
-
-static gint SignalProxy_SlotForwardPage_gtk_callback(gint current_page, gpointer data)
-{
-  Gtk::Assistant::SlotForwardPage* the_slot = static_cast<Gtk::Assistant::SlotForwardPage*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    return (*the_slot)(current_page);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-    return gint();
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_SlotForwardPage_gtk_callback_destroy(void* data)
-{
-  delete static_cast<Gtk::Assistant::SlotForwardPage*>(data);
-}
-
-
-namespace Gtk
-{
-
-void Assistant::set_forward_page_func(const SlotForwardPage& slot)
-{
-  // Create a copy of the slot object. A pointer to this will be passed
-  // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_SlotForwardPage_gtk_callback_destroy() is called.
-  SlotForwardPage* slot_copy = new SlotForwardPage(slot);
-
-  gtk_assistant_set_forward_page_func(gobj(), 
-      &SignalProxy_SlotForwardPage_gtk_callback, slot_copy,
-      &SignalProxy_SlotForwardPage_gtk_callback_destroy);
-}
-  
-
-} // namespace Gtk
-
-
-namespace
-{
-
-
-static void Assistant_signal_prepare_callback(GtkAssistant* self, GtkWidget* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,Gtk::Widget* > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo Assistant_signal_prepare_info =
-{
-  "prepare",
-  (GCallback) &Assistant_signal_prepare_callback,
-  (GCallback) &Assistant_signal_prepare_callback
-};
-
-
-static const Glib::SignalProxyInfo Assistant_signal_apply_info =
-{
-  "apply",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-static const Glib::SignalProxyInfo Assistant_signal_close_info =
-{
-  "close",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-static const Glib::SignalProxyInfo Assistant_signal_cancel_info =
-{
-  "cancel",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-} // anonymous namespace
-
-// static
-GType Glib::Value<Gtk::AssistantPageType>::value_type()
-{
-  return gtk_assistant_page_type_get_type();
-}
-
-
-namespace Glib
-{
-
-Gtk::Assistant* wrap(GtkAssistant* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::Assistant *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& Assistant_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_ = &Assistant_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(gtk_assistant_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void Assistant_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->prepare = &prepare_callback;
-  klass->apply = &apply_callback;
-  klass->close = &close_callback;
-  klass->cancel = &cancel_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Assistant_Class::prepare_callback(GtkAssistant* self, GtkWidget* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_prepare(Glib::wrap(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->prepare)
-      (*base->prepare)(self, p0);
-  }
-}
-void Assistant_Class::apply_callback(GtkAssistant* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_apply();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->apply)
-      (*base->apply)(self);
-  }
-}
-void Assistant_Class::close_callback(GtkAssistant* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_close();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->close)
-      (*base->close)(self);
-  }
-}
-void Assistant_Class::cancel_callback(GtkAssistant* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_cancel();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->cancel)
-      (*base->cancel)(self);
-  }
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* Assistant_Class::wrap_new(GObject* o)
-{
-  return new Assistant((GtkAssistant*)(o)); //top-level windows can not be manage()ed.
-
-}
-
-
-/* The implementation: */
-
-Assistant::Assistant(const Glib::ConstructParams& construct_params)
-:
-  Gtk::Window(construct_params)
-{
-  }
-
-Assistant::Assistant(GtkAssistant* castitem)
-:
-  Gtk::Window((GtkWindow*)(castitem))
-{
-  }
-
-Assistant::~Assistant()
-{
-  destroy_();
-}
-
-Assistant::CppClassType Assistant::assistant_class_; // initialize static member
-
-GType Assistant::get_type()
-{
-  return assistant_class_.init().get_type();
-}
-
-GType Assistant::get_base_type()
-{
-  return gtk_assistant_get_type();
-}
-
-
-Assistant::Assistant()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Window(Glib::ConstructParams(assistant_class_.init()))
-{
-  }
-
-int Assistant::get_current_page() const
-{
-  return gtk_assistant_get_current_page(const_cast<GtkAssistant*>(gobj()));
-}
-
-void Assistant::set_current_page(int page_num)
-{
-gtk_assistant_set_current_page(gobj(), page_num); 
-}
-
-int Assistant::get_n_pages() const
-{
-  return gtk_assistant_get_n_pages(const_cast<GtkAssistant*>(gobj()));
-}
-
-Widget* Assistant::get_nth_page(int page_num)
-{
-  return Glib::wrap(gtk_assistant_get_nth_page(gobj(), page_num));
-}
-
-const Widget* Assistant::get_nth_page(int page_num) const
-{
-  return const_cast<Assistant*>(this)->get_nth_page(page_num);
-}
-
-int Assistant::prepend_page(Widget& page)
-{
-  return gtk_assistant_prepend_page(gobj(), (page).gobj());
-}
-
-int Assistant::append_page(Widget& page)
-{
-  return gtk_assistant_append_page(gobj(), (page).gobj());
-}
-
-int Assistant::insert_page(Widget& page, int position)
-{
-  return gtk_assistant_insert_page(gobj(), (page).gobj(), position);
-}
-
-void Assistant::set_page_type(const Widget& page, AssistantPageType type)
-{
-gtk_assistant_set_page_type(gobj(), const_cast<GtkWidget*>((page).gobj()), ((GtkAssistantPageType)(type))); 
-}
-
-AssistantPageType Assistant::get_page_type(const Widget& page) const
-{
-  return ((AssistantPageType)(gtk_assistant_get_page_type(const_cast<GtkAssistant*>(gobj()), const_cast<GtkWidget*>((page).gobj()))));
-}
-
-void Assistant::set_page_title(const Widget& page, const Glib::ustring& title)
-{
-gtk_assistant_set_page_title(gobj(), const_cast<GtkWidget*>((page).gobj()), title.c_str()); 
-}
-
-Glib::ustring Assistant::get_page_title(const Widget& page) const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_assistant_get_page_title(const_cast<GtkAssistant*>(gobj()), const_cast<GtkWidget*>((page).gobj())));
-}
-
-void Assistant::set_page_header_image(const Widget& page, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
-{
-gtk_assistant_set_page_header_image(gobj(), const_cast<GtkWidget*>((page).gobj()), Glib::unwrap(pixbuf)); 
-}
-
-Glib::RefPtr<Gdk::Pixbuf> Assistant::get_page_header_image(const Widget& page)
-{
-  return Glib::wrap(gtk_assistant_get_page_header_image(gobj(), const_cast<GtkWidget*>((page).gobj())));
-}
-
-Glib::RefPtr<const Gdk::Pixbuf> Assistant::get_page_header_image(const Widget& page) const
-{
-  return const_cast<Assistant*>(this)->get_page_header_image(page);
-}
-
-void Assistant::set_page_side_image(const Widget& page, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
-{
-gtk_assistant_set_page_side_image(gobj(), const_cast<GtkWidget*>((page).gobj()), Glib::unwrap(pixbuf)); 
-}
-
-Glib::RefPtr<Gdk::Pixbuf> Assistant::get_page_side_image(const Widget& page)
-{
-  return Glib::wrap(gtk_assistant_get_page_side_image(gobj(), const_cast<GtkWidget*>((page).gobj())));
-}
-
-Glib::RefPtr<const Gdk::Pixbuf> Assistant::get_page_side_image(const Widget& page) const
-{
-  return const_cast<Assistant*>(this)->get_page_side_image(page);
-}
-
-void Assistant::set_page_complete(const Widget& page, bool complete)
-{
-gtk_assistant_set_page_complete(gobj(), const_cast<GtkWidget*>((page).gobj()), static_cast<int>(complete)); 
-}
-
-bool Assistant::get_page_complete(const Widget& page) const
-{
-  return gtk_assistant_get_page_complete(const_cast<GtkAssistant*>(gobj()), const_cast<GtkWidget*>((page).gobj()));
-}
-
-void Assistant::add_action_widget(Widget& child)
-{
-gtk_assistant_add_action_widget(gobj(), (child).gobj()); 
-}
-
-void Assistant::remove_action_widget(Widget& child)
-{
-gtk_assistant_remove_action_widget(gobj(), (child).gobj()); 
-}
-
-void Assistant::update_buttons_state()
-{
-gtk_assistant_update_buttons_state(gobj()); 
-}
-
-
-Glib::SignalProxy1< void,Gtk::Widget* > Assistant::signal_prepare()
-{
-  return Glib::SignalProxy1< void,Gtk::Widget* >(this, &Assistant_signal_prepare_info);
-}
-
-
-Glib::SignalProxy0< void > Assistant::signal_apply()
-{
-  return Glib::SignalProxy0< void >(this, &Assistant_signal_apply_info);
-}
-
-
-Glib::SignalProxy0< void > Assistant::signal_close()
-{
-  return Glib::SignalProxy0< void >(this, &Assistant_signal_close_info);
-}
-
-
-Glib::SignalProxy0< void > Assistant::signal_cancel()
-{
-  return Glib::SignalProxy0< void >(this, &Assistant_signal_cancel_info);
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Gtk::Assistant::on_prepare(Gtk::Widget* page)
-{
-  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->prepare)
-    (*base->prepare)(gobj(),(GtkWidget*)Glib::unwrap(page));
-}
-void Gtk::Assistant::on_apply()
-{
-  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->apply)
-    (*base->apply)(gobj());
-}
-void Gtk::Assistant::on_close()
-{
-  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->close)
-    (*base->close)(gobj());
-}
-void Gtk::Assistant::on_cancel()
-{
-  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->cancel)
-    (*base->cancel)(gobj());
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/assistant.h b/libs/gtkmm2/gtk/gtkmm/assistant.h
deleted file mode 100644
index f932943df4..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/assistant.h
+++ /dev/null
@@ -1,258 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_ASSISTANT_H
-#define _GTKMM_ASSISTANT_H
-
-
-#include <glibmm.h>
-
-/* $Id: assistant.hg,v 1.4 2006/06/13 17:16:26 murrayc Exp $ */
-
-/* assistant.h
- *
- * Copyright (C) 2004 The gtkmm 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/window.h>
-#include <gdkmm/pixbuf.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkAssistant GtkAssistant;
-typedef struct _GtkAssistantClass GtkAssistantClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class Assistant_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- */
-enum AssistantPageType
-{
-  ASSISTANT_PAGE_CONTENT,
-  ASSISTANT_PAGE_INTRO,
-  ASSISTANT_PAGE_CONFIRM,
-  ASSISTANT_PAGE_SUMMARY,
-  ASSISTANT_PAGE_PROGRESS
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::AssistantPageType> : public Glib::Value_Enum<Gtk::AssistantPageType>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** TODO
- *
- * @newin2p10
- * @ingroup Dialogs
- */
-
-class Assistant : public Window
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef Assistant CppObjectType;
-  typedef Assistant_Class CppClassType;
-  typedef GtkAssistant BaseObjectType;
-  typedef GtkAssistantClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~Assistant();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class Assistant_Class;
-  static CppClassType assistant_class_;
-
-  // noncopyable
-  Assistant(const Assistant&);
-  Assistant& operator=(const Assistant&);
-
-protected:
-  explicit Assistant(const Glib::ConstructParams& construct_params);
-  explicit Assistant(GtkAssistant* 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.
-  GtkAssistant*       gobj()       { return reinterpret_cast<GtkAssistant*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkAssistant* gobj() const { return reinterpret_cast<GtkAssistant*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual void on_prepare(Gtk::Widget* page);
-  virtual void on_apply();
-  virtual void on_close();
-  virtual void on_cancel();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-  
-public:
-  Assistant();
-
-  
-  int get_current_page() const;
-  
-  void set_current_page(int page_num);
-  
-  int get_n_pages() const;
-  
-  Widget* get_nth_page(int page_num);
-  
-  const Widget* get_nth_page(int page_num) const;
-  
-  int prepend_page(Widget& page);
-  
-  int append_page(Widget& page);
-  
-  int insert_page(Widget& page, int position);
-  
-  typedef sigc::slot<int, int /* current_page */> SlotForwardPage;
-
-  void set_forward_page_func(const SlotForwardPage& slot);
-  
-
-  void set_page_type(const Widget& page, AssistantPageType type);
-  
-  AssistantPageType  get_page_type(const Widget& page) const;
-  
-  void set_page_title(const Widget& page, const Glib::ustring& title);
-  
-  Glib::ustring get_page_title(const Widget& page) const;
-  
-  void set_page_header_image(const Widget& page, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
-  
-  Glib::RefPtr<Gdk::Pixbuf> get_page_header_image(const Widget& page);
-  
-  Glib::RefPtr<const Gdk::Pixbuf> get_page_header_image(const Widget& page) const;
-  
-  void set_page_side_image(const Widget& page, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
-  
-  Glib::RefPtr<Gdk::Pixbuf> get_page_side_image(const Widget& page);
-  
-  Glib::RefPtr<const Gdk::Pixbuf> get_page_side_image(const Widget& page) const;
-  
-  void set_page_complete(const Widget& page, bool complete = true);
-  
-  bool get_page_complete(const Widget& page) const;
-  
-  void add_action_widget(Widget& child);
-  
-  void remove_action_widget(Widget& child);
-  
-  void update_buttons_state();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %prepare(Gtk::Widget* page)</tt>
-   */
-
-  Glib::SignalProxy1< void,Gtk::Widget* > signal_prepare();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %apply()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_apply();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %close()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_close();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %cancel()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_cancel();
-
-
-  //TODO: Child properties?
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::Assistant
-   * @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.
-   */
-  Gtk::Assistant* wrap(GtkAssistant* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_ASSISTANT_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/bin.cc b/libs/gtkmm2/gtk/gtkmm/bin.cc
index e25a25c7fe..2b58d2954c 100644
--- a/libs/gtkmm2/gtk/gtkmm/bin.cc
+++ b/libs/gtkmm2/gtk/gtkmm/bin.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/bin.h>
 #include <gtkmm/private/bin_p.h>
 
@@ -178,19 +177,8 @@ void Bin_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Bin_Class::wrap_new(GObject* o)
 {
@@ -238,7 +226,7 @@ Bin::Bin()
 {
   }
 
- Widget* Bin::get_child()
+Widget* Bin::get_child()
 {
   return Glib::wrap(gobj()->child);
 }
@@ -247,13 +235,6 @@ const Widget* Bin::get_child() const
 {
   return Glib::wrap(gobj()->child);
 }
- 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/bin.h b/libs/gtkmm2/gtk/gtkmm/bin.h
index abeab46269..2100110f69 100644
--- a/libs/gtkmm2/gtk/gtkmm/bin.h
+++ b/libs/gtkmm2/gtk/gtkmm/bin.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_BIN_H
 #define _GTKMM_BIN_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -93,17 +92,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -116,9 +109,9 @@ public:
   // get_child() is a convenience function to get a c++ wrapper of
   // the contained widget. It may return NULL if such an item is not
   // available.
-   Widget* get_child();
+  Widget* get_child();
   const Widget* get_child() const;
- 
+
   /** Remove the contained object
    * Since this can only hold one object it is not necessary to
    * specify which object to remove like other containers.
@@ -213,8 +206,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Bin* wrap(GtkBin* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_BIN_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/box.cc b/libs/gtkmm2/gtk/gtkmm/box.cc
index 2f6a0ba157..a67411b47b 100644
--- a/libs/gtkmm2/gtk/gtkmm/box.cc
+++ b/libs/gtkmm2/gtk/gtkmm/box.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/box.h>
 #include <gtkmm/private/box_p.h>
 
@@ -176,19 +175,8 @@ void Box_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Box_Class::wrap_new(GObject* o)
 {
@@ -338,17 +326,17 @@ Box::Box()
 
 void Box::pack_start(Widget& child, bool expand, bool fill, guint padding)
 {
-gtk_box_pack_start(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), padding); 
+  gtk_box_pack_start(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), padding);
 }
 
 void Box::pack_end(Widget& child, bool expand, bool fill, guint padding)
 {
-gtk_box_pack_end(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), padding); 
+  gtk_box_pack_end(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), padding);
 }
 
 void Box::set_homogeneous(bool homogeneous)
 {
-gtk_box_set_homogeneous(gobj(), static_cast<int>(homogeneous)); 
+  gtk_box_set_homogeneous(gobj(), static_cast<int>(homogeneous));
 }
 
 bool Box::get_homogeneous() const
@@ -358,7 +346,7 @@ bool Box::get_homogeneous() const
 
 void Box::set_spacing(int spacing)
 {
-gtk_box_set_spacing(gobj(), spacing); 
+  gtk_box_set_spacing(gobj(), spacing);
 }
 
 int Box::get_spacing() const
@@ -368,44 +356,29 @@ int Box::get_spacing() const
 
 void Box::reorder_child(Widget& child, int pos)
 {
-gtk_box_reorder_child(gobj(), (child).gobj(), pos); 
+  gtk_box_reorder_child(gobj(), (child).gobj(), pos);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Box::property_spacing() 
 {
   return Glib::PropertyProxy<int>(this, "spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Box::property_spacing() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Box::property_homogeneous() 
 {
   return Glib::PropertyProxy<bool>(this, "homogeneous");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Box::property_homogeneous() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "homogeneous");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -452,19 +425,8 @@ void VBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* VBox_Class::wrap_new(GObject* o)
 {
@@ -512,13 +474,6 @@ VBox::VBox(bool homogeneous, int spacing)
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -563,19 +518,8 @@ void HBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* HBox_Class::wrap_new(GObject* o)
 {
@@ -623,13 +567,6 @@ HBox::HBox(bool homogeneous, int spacing)
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/box.h b/libs/gtkmm2/gtk/gtkmm/box.h
index a3a0e69cdd..3955273760 100644
--- a/libs/gtkmm2/gtk/gtkmm/box.h
+++ b/libs/gtkmm2/gtk/gtkmm/box.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_BOX_H
 #define _GTKMM_BOX_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -212,8 +211,7 @@ virtual void remove(Widget& w); //Implented as custom or by LIST_CONTAINER_REMOV
  * right side.  Use repeated calls to pack_start() to pack widgets into a
  * Gtk::Box from start to end. Use pack_end() to add widgets from end to start.
  * You may intersperse these calls and add widgets from both ends of the same
- * Gtk::Box. The last widget added with pack_start() will be placed just before
- * the last widget added with pack_end()
+ * Gtk::Box.
  *
  * Because Gtk::Box is a Gtk::Container, you may also use Gtk::Container::add()
  * to insert widgets, and they will be packed as if with pack_start(). Use
@@ -270,17 +268,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -362,17 +354,14 @@ public:
    */
   const BoxList& children() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The amount of space between children.
+  /** The amount of space between children.
    *
    * 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_spacing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The amount of space between children.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -380,19 +369,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_spacing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the children should all be the same size.
+  /** Whether the children should all be the same 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<bool> property_homogeneous() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the children should all be the same size.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -400,7 +385,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_homogeneous() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -466,17 +450,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -553,17 +531,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -592,9 +564,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Box* wrap(GtkBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::VBox
@@ -603,9 +573,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::VBox* wrap(GtkVBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::HBox
@@ -614,8 +582,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HBox* wrap(GtkHBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_BOX_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/button.cc b/libs/gtkmm2/gtk/gtkmm/button.cc
index 4c4bbd8230..01a3265d8c 100644
--- a/libs/gtkmm2/gtk/gtkmm/button.cc
+++ b/libs/gtkmm2/gtk/gtkmm/button.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/button.h>
 #include <gtkmm/private/button_p.h>
 
@@ -53,8 +52,7 @@ Button::Button(const StockID& stock_id)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Button_signal_pressed_info =
+const Glib::SignalProxyInfo Button_signal_pressed_info =
 {
   "pressed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -62,7 +60,7 @@ static const Glib::SignalProxyInfo Button_signal_pressed_info =
 };
 
 
-static const Glib::SignalProxyInfo Button_signal_released_info =
+const Glib::SignalProxyInfo Button_signal_released_info =
 {
   "released",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -70,7 +68,7 @@ static const Glib::SignalProxyInfo Button_signal_released_info =
 };
 
 
-static const Glib::SignalProxyInfo Button_signal_clicked_info =
+const Glib::SignalProxyInfo Button_signal_clicked_info =
 {
   "clicked",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -78,7 +76,7 @@ static const Glib::SignalProxyInfo Button_signal_clicked_info =
 };
 
 
-static const Glib::SignalProxyInfo Button_signal_enter_info =
+const Glib::SignalProxyInfo Button_signal_enter_info =
 {
   "enter",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -86,7 +84,7 @@ static const Glib::SignalProxyInfo Button_signal_enter_info =
 };
 
 
-static const Glib::SignalProxyInfo Button_signal_leave_info =
+const Glib::SignalProxyInfo Button_signal_leave_info =
 {
   "leave",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -94,14 +92,13 @@ static const Glib::SignalProxyInfo Button_signal_leave_info =
 };
 
 
-static const Glib::SignalProxyInfo Button_signal_activate_info =
+const Glib::SignalProxyInfo Button_signal_activate_info =
 {
   "activate",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -146,23 +143,15 @@ void Button_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->pressed = &pressed_callback;
   klass->released = &released_callback;
   klass->clicked = &clicked_callback;
   klass->enter = &enter_callback;
   klass->leave = &leave_callback;
   klass->activate = &activate_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Button_Class::pressed_callback(GtkButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -175,19 +164,15 @@ void Button_Class::pressed_callback(GtkButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_pressed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -200,6 +185,7 @@ void Button_Class::pressed_callback(GtkButton* self)
       (*base->pressed)(self);
   }
 }
+
 void Button_Class::released_callback(GtkButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -212,19 +198,15 @@ void Button_Class::released_callback(GtkButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_released();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -237,6 +219,7 @@ void Button_Class::released_callback(GtkButton* self)
       (*base->released)(self);
   }
 }
+
 void Button_Class::clicked_callback(GtkButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -249,19 +232,15 @@ void Button_Class::clicked_callback(GtkButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_clicked();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -274,6 +253,7 @@ void Button_Class::clicked_callback(GtkButton* self)
       (*base->clicked)(self);
   }
 }
+
 void Button_Class::enter_callback(GtkButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -286,19 +266,15 @@ void Button_Class::enter_callback(GtkButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_enter();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -311,6 +287,7 @@ void Button_Class::enter_callback(GtkButton* self)
       (*base->enter)(self);
   }
 }
+
 void Button_Class::leave_callback(GtkButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -323,19 +300,15 @@ void Button_Class::leave_callback(GtkButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_leave();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -348,6 +321,7 @@ void Button_Class::leave_callback(GtkButton* self)
       (*base->leave)(self);
   }
 }
+
 void Button_Class::activate_callback(GtkButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -360,19 +334,15 @@ void Button_Class::activate_callback(GtkButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_activate();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -385,7 +355,6 @@ void Button_Class::activate_callback(GtkButton* self)
       (*base->activate)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Button_Class::wrap_new(GObject* o)
@@ -436,32 +405,32 @@ Button::Button()
 
 void Button::pressed()
 {
-gtk_button_pressed(gobj()); 
+  gtk_button_pressed(gobj());
 }
 
 void Button::released()
 {
-gtk_button_released(gobj()); 
+  gtk_button_released(gobj());
 }
 
 void Button::clicked()
 {
-gtk_button_clicked(gobj()); 
+  gtk_button_clicked(gobj());
 }
 
 void Button::enter()
 {
-gtk_button_enter(gobj()); 
+  gtk_button_enter(gobj());
 }
 
 void Button::leave()
 {
-gtk_button_leave(gobj()); 
+  gtk_button_leave(gobj());
 }
 
 void Button::set_relief(ReliefStyle newstyle)
 {
-gtk_button_set_relief(gobj(), ((GtkReliefStyle)(newstyle))); 
+  gtk_button_set_relief(gobj(), ((GtkReliefStyle)(newstyle)));
 }
 
 ReliefStyle Button::get_relief() const
@@ -471,7 +440,7 @@ ReliefStyle Button::get_relief() const
 
 void Button::set_label(const Glib::ustring& label)
 {
-gtk_button_set_label(gobj(), label.c_str()); 
+  gtk_button_set_label(gobj(), label.c_str());
 }
 
 Glib::ustring Button::get_label() const
@@ -481,7 +450,7 @@ Glib::ustring Button::get_label() const
 
 void Button::set_use_underline(bool use_underline)
 {
-gtk_button_set_use_underline(gobj(), static_cast<int>(use_underline)); 
+  gtk_button_set_use_underline(gobj(), static_cast<int>(use_underline));
 }
 
 bool Button::get_use_underline() const
@@ -491,7 +460,7 @@ bool Button::get_use_underline() const
 
 void Button::set_use_stock(bool use_stock)
 {
-gtk_button_set_use_stock(gobj(), static_cast<int>(use_stock)); 
+  gtk_button_set_use_stock(gobj(), static_cast<int>(use_stock));
 }
 
 bool Button::get_use_stock() const
@@ -501,7 +470,7 @@ bool Button::get_use_stock() const
 
 void Button::set_focus_on_click(bool focus_on_click)
 {
-gtk_button_set_focus_on_click(gobj(), static_cast<int>(focus_on_click)); 
+  gtk_button_set_focus_on_click(gobj(), static_cast<int>(focus_on_click));
 }
 
 bool Button::get_focus_on_click() const
@@ -511,17 +480,17 @@ bool Button::get_focus_on_click() const
 
 void Button::set_alignment(float xalign, float yalign)
 {
-gtk_button_set_alignment(gobj(), xalign, yalign); 
+  gtk_button_set_alignment(gobj(), xalign, yalign);
 }
 
 void Button::get_alignment(float& xalign, float& yalign)
 {
-gtk_button_get_alignment(gobj(), &(xalign), &(yalign)); 
+  gtk_button_get_alignment(gobj(), &(xalign), &(yalign));
 }
 
 void Button::set_image(Widget& image)
 {
-gtk_button_set_image(gobj(), (image).gobj()); 
+  gtk_button_set_image(gobj(), (image).gobj());
 }
 
 Widget* Button::get_image()
@@ -531,17 +500,7 @@ Widget* Button::get_image()
 
 const Widget* Button::get_image() const
 {
-  return const_cast<Button*>(this)->get_image();
-}
-
-void Button::set_image_position(PositionType position)
-{
-gtk_button_set_image_position(gobj(), ((GtkPositionType)(position))); 
-}
-
-PositionType Button::get_image_position() const
-{
-  return ((PositionType)(gtk_button_get_image_position(const_cast<GtkButton*>(gobj()))));
+  return Glib::wrap(gtk_button_get_image(const_cast<GtkButton*>(gobj())));
 }
 
 
@@ -550,165 +509,113 @@ Glib::SignalProxy0< void > Button::signal_pressed()
   return Glib::SignalProxy0< void >(this, &Button_signal_pressed_info);
 }
 
-
 Glib::SignalProxy0< void > Button::signal_released()
 {
   return Glib::SignalProxy0< void >(this, &Button_signal_released_info);
 }
 
-
 Glib::SignalProxy0< void > Button::signal_clicked()
 {
   return Glib::SignalProxy0< void >(this, &Button_signal_clicked_info);
 }
 
-
 Glib::SignalProxy0< void > Button::signal_enter()
 {
   return Glib::SignalProxy0< void >(this, &Button_signal_enter_info);
 }
 
-
 Glib::SignalProxy0< void > Button::signal_leave()
 {
   return Glib::SignalProxy0< void >(this, &Button_signal_leave_info);
 }
 
-
 Glib::SignalProxy0< void > Button::signal_activate()
 {
   return Glib::SignalProxy0< void >(this, &Button_signal_activate_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Button::property_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Button::property_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ReliefStyle> Button::property_relief() 
 {
   return Glib::PropertyProxy<ReliefStyle>(this, "relief");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ReliefStyle> Button::property_relief() const
 {
   return Glib::PropertyProxy_ReadOnly<ReliefStyle>(this, "relief");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Button::property_use_underline() 
 {
   return Glib::PropertyProxy<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Button::property_use_underline() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Button::property_use_stock() 
 {
   return Glib::PropertyProxy<bool>(this, "use-stock");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Button::property_use_stock() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-stock");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Button::property_focus_on_click() 
 {
   return Glib::PropertyProxy<bool>(this, "focus-on-click");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Button::property_focus_on_click() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "focus-on-click");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Button::property_xalign() 
 {
   return Glib::PropertyProxy<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Button::property_xalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Button::property_yalign() 
 {
   return Glib::PropertyProxy<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Button::property_yalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Widget*> Button::property_image() 
 {
   return Glib::PropertyProxy<Gtk::Widget*>(this, "image");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Widget*> Button::property_image() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "image");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<PositionType> Button::property_image_position() 
-{
-  return Glib::PropertyProxy<PositionType>(this, "image-position");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<PositionType> Button::property_image_position() const
-{
-  return Glib::PropertyProxy_ReadOnly<PositionType>(this, "image-position");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Button::on_pressed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -718,6 +625,7 @@ void Gtk::Button::on_pressed()
   if(base && base->pressed)
     (*base->pressed)(gobj());
 }
+
 void Gtk::Button::on_released()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -727,6 +635,7 @@ void Gtk::Button::on_released()
   if(base && base->released)
     (*base->released)(gobj());
 }
+
 void Gtk::Button::on_clicked()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -736,6 +645,7 @@ void Gtk::Button::on_clicked()
   if(base && base->clicked)
     (*base->clicked)(gobj());
 }
+
 void Gtk::Button::on_enter()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -745,6 +655,7 @@ void Gtk::Button::on_enter()
   if(base && base->enter)
     (*base->enter)(gobj());
 }
+
 void Gtk::Button::on_leave()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -754,6 +665,7 @@ void Gtk::Button::on_leave()
   if(base && base->leave)
     (*base->leave)(gobj());
 }
+
 void Gtk::Button::on_activate()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -763,10 +675,6 @@ void Gtk::Button::on_activate()
   if(base && base->activate)
     (*base->activate)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/button.h b/libs/gtkmm2/gtk/gtkmm/button.h
index 990ede4163..1ba9920a0f 100644
--- a/libs/gtkmm2/gtk/gtkmm/button.h
+++ b/libs/gtkmm2/gtk/gtkmm/button.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_BUTTON_H
 #define _GTKMM_BUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,23 +95,17 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_pressed();
   virtual void on_released();
   virtual void on_clicked();
   virtual void on_enter();
   virtual void on_leave();
   virtual void on_activate();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -129,7 +122,7 @@ public:
    * directly instead.
    */
   Button();
-
+  
 
   /** Simple Push Button with label.
    * Create a button with the given label inside. You won't be able
@@ -137,11 +130,6 @@ public:
    * in it
    */
   explicit Button(const Glib::ustring& label, bool mnemonic = false);
-
-  /** Creates a new Button containing the image and text from a stock item.
-   * Stock ids have identifiers like Gtk::Stock::OK and Gtk::Stock::APPLY.
-   * @param stock_id The stock item.
-   */
   explicit Button(const StockID& stock_id);
 
 
@@ -212,7 +200,7 @@ public:
    * you don't want the keyboard focus removed from the main area of the
    * application.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param focus_on_click Whether the button grabs focus when clicked with the mouse.
    */
   void set_focus_on_click(bool focus_on_click = true);
@@ -222,7 +210,7 @@ public:
    * @return <tt>true</tt> if the button grabs focus when it is clicked with
    * the mouse.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_focus_on_click() const;
 
@@ -230,7 +218,7 @@ public:
   /** Sets the alignment of the child. This property has no effect unless 
    * the child is a Gtk::Misc or a Gtk::Aligment.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param xalign The horizontal position of the child, 0.0 is left aligned, 
    * 1.0 is right aligned.
    * @param yalign The vertical position of the child, 0.0 is top aligned, 
@@ -240,7 +228,7 @@ public:
   
   /** Gets the alignment of the child in the button.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param xalign Return location for horizontal alignment.
    * @param yalign Return location for vertical alignment.
    */
@@ -248,96 +236,57 @@ public:
 
   
   /** Set the image of @a button  to the given widget. Note that
-   * it depends on the gtk-button-images setting whether the
-   * image will be displayed or not, you don't have to call
-   * Gtk::Widget::show() on @a image  yourself.
+   * it depends on the show-button-images setting whether the
+   * image will be displayed or not.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param image A widget to set as the image for the button.
    */
   void set_image(Widget& image);
   
   /** Gets the widget that is currenty set as the image of @a button .
-   *     This may have been explicitly set by set_image()
-   *     or specified as a stock item to the constructor.
+   * This may have been explicitly set by set_image()
+   * or constructed by new_from_stock().
    * 
-   *     @a newin2p6 
+   * Since: 2.6
    */
   Widget* get_image();
   
   /** Gets the widget that is currenty set as the image of @a button .
-   *     This may have been explicitly set by set_image()
-   *     or specified as a stock item to the constructor.
+   * This may have been explicitly set by set_image()
+   * or constructed by new_from_stock().
    * 
-   *     @a newin2p6 
+   * Since: 2.6
    */
   const Widget* get_image() const;
-
+   
   
-  void set_image_position(PositionType position);
-  
-  PositionType get_image_position() const;
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %pressed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_pressed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %released()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_released();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %clicked()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_clicked();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %enter()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_enter();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %leave()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_leave();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %activate()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_activate();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text of the label widget inside the button
+  /** Text of the label widget inside the button
    *
    * 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_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text of the label widget inside the button
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -345,19 +294,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The border relief style.
+  /** The border relief 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<ReliefStyle> property_relief() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The border relief style.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -365,19 +310,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ReliefStyle> property_relief() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If set
+  /** If 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<bool> property_use_underline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -385,19 +326,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If set
+  /** If 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<bool> property_use_stock() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -405,19 +342,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_stock() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the button grabs focus when it is clicked with the mouse.
+  /** Whether the button grabs focus when it is clicked with the mouse.
    *
    * 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_focus_on_click() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the button grabs focus when it is clicked with the mouse.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -425,19 +358,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_focus_on_click() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Horizontal position of child in available space. 0.0 is left aligned
+  /** Horizontal position of child in available space. 0.0 is left aligned
    *
    * 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<float> property_xalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Horizontal position of child in available space. 0.0 is left aligned
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -445,19 +374,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Vertical position of child in available space. 0.0 is top aligned
+  /** Vertical position of child in available space. 0.0 is top aligned
    *
    * 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<float> property_yalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Vertical position of child in available space. 0.0 is top aligned
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -465,19 +390,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Child widget to appear next to the button text.
+  /** Child widget to appear next to the button 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<Gtk::Widget*> property_image() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Child widget to appear next to the button text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -485,27 +406,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_image() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The position of the image relative to the 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<PositionType> property_image_position() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The position of the image relative to the 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<PositionType> property_image_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -527,8 +427,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Button* wrap(GtkButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_BUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/buttonbox.cc b/libs/gtkmm2/gtk/gtkmm/buttonbox.cc
index 72f0ad3f73..7fe9bd53f6 100644
--- a/libs/gtkmm2/gtk/gtkmm/buttonbox.cc
+++ b/libs/gtkmm2/gtk/gtkmm/buttonbox.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/buttonbox.h>
 #include <gtkmm/private/buttonbox_p.h>
 
@@ -99,19 +98,8 @@ void ButtonBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ButtonBox_Class::wrap_new(GObject* o)
 {
@@ -159,12 +147,12 @@ ButtonBoxStyle ButtonBox::get_layout() const
 
 void ButtonBox::set_layout(ButtonBoxStyle layout_style)
 {
-gtk_button_box_set_layout(gobj(), ((GtkButtonBoxStyle)(layout_style))); 
+  gtk_button_box_set_layout(gobj(), ((GtkButtonBoxStyle)(layout_style)));
 }
 
 void ButtonBox::set_child_secondary(Widget& child, bool is_secondary)
 {
-gtk_button_box_set_child_secondary(gobj(), (child).gobj(), static_cast<int>(is_secondary)); 
+  gtk_button_box_set_child_secondary(gobj(), (child).gobj(), static_cast<int>(is_secondary));
 }
 
 bool ButtonBox::get_child_secondary(const Gtk::Widget& child) const
@@ -172,67 +160,56 @@ bool ButtonBox::get_child_secondary(const Gtk::Widget& child) const
   return gtk_button_box_get_child_secondary(const_cast<GtkButtonBox*>(gobj()), const_cast<GtkWidget*>(child.gobj()));
 }
 
- int ButtonBox::get_child_min_width() const
+int ButtonBox::get_child_min_width() const
 {
   return gobj()->child_min_width;
 }
- 
- void ButtonBox::set_child_min_width(const int& value)
+
+void ButtonBox::set_child_min_width(const int& value)
 {
   gobj()->child_min_width = value;
 }
- 
- int ButtonBox::get_child_min_height() const
+
+int ButtonBox::get_child_min_height() const
 {
   return gobj()->child_min_height;
 }
- 
- void ButtonBox::set_child_min_height(const int& value)
+
+void ButtonBox::set_child_min_height(const int& value)
 {
   gobj()->child_min_height = value;
 }
- 
- int ButtonBox::get_child_ipadding_x() const
+
+int ButtonBox::get_child_ipadding_x() const
 {
   return gobj()->child_ipad_x;
 }
- 
- void ButtonBox::set_child_ipadding_x(const int& value)
+
+void ButtonBox::set_child_ipadding_x(const int& value)
 {
   gobj()->child_ipad_x = value;
 }
- 
- int ButtonBox::get_child_ipadding_y() const
+
+int ButtonBox::get_child_ipadding_y() const
 {
   return gobj()->child_ipad_y;
 }
- 
- void ButtonBox::set_child_ipadding_y(const int& value)
+
+void ButtonBox::set_child_ipadding_y(const int& value)
 {
   gobj()->child_ipad_y = value;
 }
- 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+
 Glib::PropertyProxy<ButtonBoxStyle> ButtonBox::property_layout_style() 
 {
   return Glib::PropertyProxy<ButtonBoxStyle>(this, "layout-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ButtonBoxStyle> ButtonBox::property_layout_style() const
 {
   return Glib::PropertyProxy_ReadOnly<ButtonBoxStyle>(this, "layout-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -279,19 +256,8 @@ void VButtonBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* VButtonBox_Class::wrap_new(GObject* o)
 {
@@ -332,13 +298,6 @@ GType VButtonBox::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -383,19 +342,8 @@ void HButtonBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* HButtonBox_Class::wrap_new(GObject* o)
 {
@@ -436,13 +384,6 @@ GType HButtonBox::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/buttonbox.h b/libs/gtkmm2/gtk/gtkmm/buttonbox.h
index 7d0665f92b..6f39c6aed9 100644
--- a/libs/gtkmm2/gtk/gtkmm/buttonbox.h
+++ b/libs/gtkmm2/gtk/gtkmm/buttonbox.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_BUTTONBOX_H
 #define _GTKMM_BUTTONBOX_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -112,17 +111,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -140,7 +133,7 @@ public:
    * 
    * This group appears after the other children if the style
    * is Gtk::BUTTONBOX_START, Gtk::BUTTONBOX_SPREAD or
-   * Gtk::BUTTONBOX_EDGE, and before the other children if the style
+   * Gtk::BUTTONBOX_EDGE, and before the the other children if the style
    * is Gtk::BUTTONBOX_END. For horizontal button boxes, the definition
    * of before/after depends on direction of the widget (see
    * Gtk::Widget::set_direction()). If the style is Gtk::BUTTONBOX_START
@@ -157,33 +150,30 @@ public:
    * @param child A child of @a widget .
    * @return Whether @a child  should appear in a secondary group of children.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_child_secondary(const Gtk::Widget& child) const;
 
-   int get_child_min_width() const;
-    void set_child_min_width(const int& value);
- 
-   int get_child_min_height() const;
-    void set_child_min_height(const int& value);
- 
-   int get_child_ipadding_x() const;
-    void set_child_ipadding_x(const int& value);
- 
-   int get_child_ipadding_y() const;
-    void set_child_ipadding_y(const int& value);
- 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** How to layout the buttons in the box. Possible values are default
+  int get_child_min_width() const;
+  void set_child_min_width(const int& value);
+
+  int get_child_min_height() const;
+  void set_child_min_height(const int& value);
+
+  int get_child_ipadding_x() const;
+  void set_child_ipadding_x(const int& value);
+
+  int get_child_ipadding_y() const;
+  void set_child_ipadding_y(const int& value);
+
+  /** How to layout the buttons in the box. Possible values are default
    *
    * 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<ButtonBoxStyle> property_layout_style() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** How to layout the buttons in the box. Possible values are default
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -191,7 +181,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ButtonBoxStyle> property_layout_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -252,17 +241,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -329,17 +312,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -361,9 +338,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ButtonBox* wrap(GtkButtonBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::VButtonBox
@@ -372,9 +347,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::VButtonBox* wrap(GtkVButtonBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::HButtonBox
@@ -383,8 +356,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HButtonBox* wrap(GtkHButtonBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_BUTTONBOX_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/calendar.cc b/libs/gtkmm2/gtk/gtkmm/calendar.cc
index 819d4229b9..66add813c7 100644
--- a/libs/gtkmm2/gtk/gtkmm/calendar.cc
+++ b/libs/gtkmm2/gtk/gtkmm/calendar.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/calendar.h>
 #include <gtkmm/private/calendar_p.h>
 
@@ -38,8 +37,7 @@ namespace Gtk
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Calendar_signal_month_changed_info =
+const Glib::SignalProxyInfo Calendar_signal_month_changed_info =
 {
   "month_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -47,7 +45,7 @@ static const Glib::SignalProxyInfo Calendar_signal_month_changed_info =
 };
 
 
-static const Glib::SignalProxyInfo Calendar_signal_day_selected_info =
+const Glib::SignalProxyInfo Calendar_signal_day_selected_info =
 {
   "day_selected",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -55,7 +53,7 @@ static const Glib::SignalProxyInfo Calendar_signal_day_selected_info =
 };
 
 
-static const Glib::SignalProxyInfo Calendar_signal_day_selected_double_click_info =
+const Glib::SignalProxyInfo Calendar_signal_day_selected_double_click_info =
 {
   "day_selected_double_click",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -63,7 +61,7 @@ static const Glib::SignalProxyInfo Calendar_signal_day_selected_double_click_inf
 };
 
 
-static const Glib::SignalProxyInfo Calendar_signal_prev_month_info =
+const Glib::SignalProxyInfo Calendar_signal_prev_month_info =
 {
   "prev_month",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -71,7 +69,7 @@ static const Glib::SignalProxyInfo Calendar_signal_prev_month_info =
 };
 
 
-static const Glib::SignalProxyInfo Calendar_signal_next_month_info =
+const Glib::SignalProxyInfo Calendar_signal_next_month_info =
 {
   "next_month",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -79,7 +77,7 @@ static const Glib::SignalProxyInfo Calendar_signal_next_month_info =
 };
 
 
-static const Glib::SignalProxyInfo Calendar_signal_prev_year_info =
+const Glib::SignalProxyInfo Calendar_signal_prev_year_info =
 {
   "prev_year",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -87,14 +85,13 @@ static const Glib::SignalProxyInfo Calendar_signal_prev_year_info =
 };
 
 
-static const Glib::SignalProxyInfo Calendar_signal_next_year_info =
+const Glib::SignalProxyInfo Calendar_signal_next_year_info =
 {
   "next_year",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -145,10 +142,6 @@ void Calendar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->month_changed = &month_changed_callback;
   klass->day_selected = &day_selected_callback;
   klass->day_selected_double_click = &day_selected_double_click_callback;
@@ -156,13 +149,9 @@ void Calendar_Class::class_init_function(void* g_class, void* class_data)
   klass->next_month = &next_month_callback;
   klass->prev_year = &prev_year_callback;
   klass->next_year = &next_year_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Calendar_Class::month_changed_callback(GtkCalendar* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -175,19 +164,15 @@ void Calendar_Class::month_changed_callback(GtkCalendar* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_month_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -200,6 +185,7 @@ void Calendar_Class::month_changed_callback(GtkCalendar* self)
       (*base->month_changed)(self);
   }
 }
+
 void Calendar_Class::day_selected_callback(GtkCalendar* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -212,19 +198,15 @@ void Calendar_Class::day_selected_callback(GtkCalendar* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_day_selected();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -237,6 +219,7 @@ void Calendar_Class::day_selected_callback(GtkCalendar* self)
       (*base->day_selected)(self);
   }
 }
+
 void Calendar_Class::day_selected_double_click_callback(GtkCalendar* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -249,19 +232,15 @@ void Calendar_Class::day_selected_double_click_callback(GtkCalendar* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_day_selected_double_click();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -274,6 +253,7 @@ void Calendar_Class::day_selected_double_click_callback(GtkCalendar* self)
       (*base->day_selected_double_click)(self);
   }
 }
+
 void Calendar_Class::prev_month_callback(GtkCalendar* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -286,19 +266,15 @@ void Calendar_Class::prev_month_callback(GtkCalendar* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_prev_month();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -311,6 +287,7 @@ void Calendar_Class::prev_month_callback(GtkCalendar* self)
       (*base->prev_month)(self);
   }
 }
+
 void Calendar_Class::next_month_callback(GtkCalendar* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -323,19 +300,15 @@ void Calendar_Class::next_month_callback(GtkCalendar* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_next_month();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -348,6 +321,7 @@ void Calendar_Class::next_month_callback(GtkCalendar* self)
       (*base->next_month)(self);
   }
 }
+
 void Calendar_Class::prev_year_callback(GtkCalendar* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -360,19 +334,15 @@ void Calendar_Class::prev_year_callback(GtkCalendar* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_prev_year();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -385,6 +355,7 @@ void Calendar_Class::prev_year_callback(GtkCalendar* self)
       (*base->prev_year)(self);
   }
 }
+
 void Calendar_Class::next_year_callback(GtkCalendar* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -397,19 +368,15 @@ void Calendar_Class::next_year_callback(GtkCalendar* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_next_year();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -422,7 +389,6 @@ void Calendar_Class::next_year_callback(GtkCalendar* self)
       (*base->next_year)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Calendar_Class::wrap_new(GObject* o)
@@ -478,7 +444,7 @@ int Calendar::select_month(guint month, guint year)
 
 void Calendar::select_day(guint day)
 {
-gtk_calendar_select_day(gobj(), day); 
+  gtk_calendar_select_day(gobj(), day);
 }
 
 int Calendar::mark_day(guint day)
@@ -493,21 +459,17 @@ int Calendar::unmark_day(guint day)
 
 void Calendar::clear_marks()
 {
-gtk_calendar_clear_marks(gobj()); 
+  gtk_calendar_clear_marks(gobj());
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void Calendar::display_options(CalendarDisplayOptions flags)
 {
-gtk_calendar_display_options(gobj(), ((GtkCalendarDisplayOptions)(flags))); 
+  gtk_calendar_display_options(gobj(), ((GtkCalendarDisplayOptions)(flags)));
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 void Calendar::set_display_options(CalendarDisplayOptions flags)
 {
-gtk_calendar_set_display_options(gobj(), ((GtkCalendarDisplayOptions)(flags))); 
+  gtk_calendar_set_display_options(gobj(), ((GtkCalendarDisplayOptions)(flags)));
 }
 
 CalendarDisplayOptions Calendar::get_display_options() const
@@ -517,17 +479,17 @@ CalendarDisplayOptions Calendar::get_display_options() const
 
 void Calendar::get_date(guint& year, guint& month, guint& day) const
 {
-gtk_calendar_get_date(const_cast<GtkCalendar*>(gobj()), &(year), &(month), &(day)); 
+  gtk_calendar_get_date(const_cast<GtkCalendar*>(gobj()), &(year), &(month), &(day));
 }
 
 void Calendar::freeze()
 {
-gtk_calendar_freeze(gobj()); 
+  gtk_calendar_freeze(gobj());
 }
 
 void Calendar::thaw()
 {
-gtk_calendar_thaw(gobj()); 
+  gtk_calendar_thaw(gobj());
 }
 
 
@@ -536,44 +498,37 @@ Glib::SignalProxy0< void > Calendar::signal_month_changed()
   return Glib::SignalProxy0< void >(this, &Calendar_signal_month_changed_info);
 }
 
-
 Glib::SignalProxy0< void > Calendar::signal_day_selected()
 {
   return Glib::SignalProxy0< void >(this, &Calendar_signal_day_selected_info);
 }
 
-
 Glib::SignalProxy0< void > Calendar::signal_day_selected_double_click()
 {
   return Glib::SignalProxy0< void >(this, &Calendar_signal_day_selected_double_click_info);
 }
 
-
 Glib::SignalProxy0< void > Calendar::signal_prev_month()
 {
   return Glib::SignalProxy0< void >(this, &Calendar_signal_prev_month_info);
 }
 
-
 Glib::SignalProxy0< void > Calendar::signal_next_month()
 {
   return Glib::SignalProxy0< void >(this, &Calendar_signal_next_month_info);
 }
 
-
 Glib::SignalProxy0< void > Calendar::signal_prev_year()
 {
   return Glib::SignalProxy0< void >(this, &Calendar_signal_prev_year_info);
 }
 
-
 Glib::SignalProxy0< void > Calendar::signal_next_year()
 {
   return Glib::SignalProxy0< void >(this, &Calendar_signal_next_year_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Calendar::on_month_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -583,6 +538,7 @@ void Gtk::Calendar::on_month_changed()
   if(base && base->month_changed)
     (*base->month_changed)(gobj());
 }
+
 void Gtk::Calendar::on_day_selected()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -592,6 +548,7 @@ void Gtk::Calendar::on_day_selected()
   if(base && base->day_selected)
     (*base->day_selected)(gobj());
 }
+
 void Gtk::Calendar::on_day_selected_double_click()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -601,6 +558,7 @@ void Gtk::Calendar::on_day_selected_double_click()
   if(base && base->day_selected_double_click)
     (*base->day_selected_double_click)(gobj());
 }
+
 void Gtk::Calendar::on_prev_month()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -610,6 +568,7 @@ void Gtk::Calendar::on_prev_month()
   if(base && base->prev_month)
     (*base->prev_month)(gobj());
 }
+
 void Gtk::Calendar::on_next_month()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -619,6 +578,7 @@ void Gtk::Calendar::on_next_month()
   if(base && base->next_month)
     (*base->next_month)(gobj());
 }
+
 void Gtk::Calendar::on_prev_year()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -628,6 +588,7 @@ void Gtk::Calendar::on_prev_year()
   if(base && base->prev_year)
     (*base->prev_year)(gobj());
 }
+
 void Gtk::Calendar::on_next_year()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -637,10 +598,6 @@ void Gtk::Calendar::on_next_year()
   if(base && base->next_year)
     (*base->next_year)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/calendar.h b/libs/gtkmm2/gtk/gtkmm/calendar.h
index 915ba1af21..a026c941e6 100644
--- a/libs/gtkmm2/gtk/gtkmm/calendar.h
+++ b/libs/gtkmm2/gtk/gtkmm/calendar.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CALENDAR_H
 #define _GTKMM_CALENDAR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -176,16 +175,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_month_changed();
   virtual void on_day_selected();
   virtual void on_day_selected_double_click();
@@ -193,7 +187,6 @@ protected:
   virtual void on_next_month();
   virtual void on_prev_year();
   virtual void on_next_year();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -202,51 +195,26 @@ public:
   Calendar();
   
   
-  /** Shifts the calendar to a different month.
-   * @param month A month number between 0 and 11.
-   * @param year The year the month is in.
-   * @return <tt>true</tt>, always.
-   */
   int select_month(guint month, guint year);
   
-  /** Selects a day from the current month.
-   * @param day The day number between 1 and 31, or 0 to unselect 
-   * the currently selected day.
-   */
   void select_day(guint day);
   
-  /** Places a visual marker on a particular day.
-   * @param day The day number to mark between 1 and 31.
-   * @return <tt>true</tt>, always.
-   */
   int mark_day(guint day);
   
-  /** Removes the visual marker from a particular day.
-   * @param day The day number to unmark between 1 and 31.
-   * @return <tt>true</tt>, always.
-   */
   int unmark_day(guint day);
   
-  /** Remove all visual markers.
-   */
   void clear_marks();
 
+  #ifndef GTKMM_DISABLE_DEPRECATED
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-  /** Sets display options (whether to display the heading and the month headings).
-   * 
-   * Deprecated: Use set_display_options() instead
-   * @param flags The display options to set.
-   */
   void display_options(CalendarDisplayOptions flags);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
+  #endif //GTKMM_DISABLE_DEPRECATED
+  
+  
   /** Sets display options (whether to display the heading and the month  
    * headings).
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param flags The display options to set.
    */
   void set_display_options(CalendarDisplayOptions flags);
@@ -254,82 +222,36 @@ public:
   /** Returns the current display options of @a calendar .
    * @return The display options.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   CalendarDisplayOptions get_display_options() const;
 
   
-  /** Obtains the selected date from a Gtk::Calendar.
-   * @param year Location to store the year number, or <tt>0</tt>.
-   * @param month Location to store the month number (between 0 and 11), or <tt>0</tt>.
-   * @param day Location to store the day number (between 1 and 31), or <tt>0</tt>.
-   */
   void get_date(guint& year, guint& month, guint& day) const;
   
-  /** Does nothing. Previously locked the display of the calendar until
-   * it was thawed with thaw().
-   */
   void freeze();
   
-  /** Does nothing. Previously defrosted a calendar; all the changes made
-   * since the last freeze() were displayed.
-   */
   void thaw();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %month_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_month_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %day_selected()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_day_selected();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %day_selected_double_click()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_day_selected_double_click();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %prev_month()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_prev_month();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %next_month()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_next_month();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %prev_year()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_prev_year();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %next_year()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_next_year();
 
 
@@ -346,8 +268,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Calendar* wrap(GtkCalendar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CALENDAR_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/celleditable.cc b/libs/gtkmm2/gtk/gtkmm/celleditable.cc
index a2013f9d5e..2f0d2a5b1b 100644
--- a/libs/gtkmm2/gtk/gtkmm/celleditable.cc
+++ b/libs/gtkmm2/gtk/gtkmm/celleditable.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/celleditable.h>
 #include <gtkmm/private/celleditable_p.h>
 
@@ -30,8 +29,7 @@
 namespace
 {
 
-
-static const Glib::SignalProxyInfo CellEditable_signal_editing_done_info =
+const Glib::SignalProxyInfo CellEditable_signal_editing_done_info =
 {
   "editing_done",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -39,14 +37,13 @@ static const Glib::SignalProxyInfo CellEditable_signal_editing_done_info =
 };
 
 
-static const Glib::SignalProxyInfo CellEditable_signal_remove_widget_info =
+const Glib::SignalProxyInfo CellEditable_signal_remove_widget_info =
 {
   "remove_widget",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -91,17 +88,11 @@ void CellEditable_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->start_editing = &start_editing_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->editing_done = &editing_done_callback;
   klass->remove_widget = &remove_widget_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void CellEditable_Class::start_editing_vfunc_callback(GtkCellEditable* self, GdkEvent* event)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -114,19 +105,15 @@ void CellEditable_Class::start_editing_vfunc_callback(GtkCellEditable* self, Gdk
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->start_editing_vfunc(event);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -140,9 +127,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->start_editing)(self, event);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void CellEditable_Class::editing_done_callback(GtkCellEditable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -155,19 +141,15 @@ void CellEditable_Class::editing_done_callback(GtkCellEditable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_editing_done();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -181,6 +163,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->editing_done)(self);
   }
 }
+
 void CellEditable_Class::remove_widget_callback(GtkCellEditable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -193,19 +176,15 @@ void CellEditable_Class::remove_widget_callback(GtkCellEditable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_remove_widget();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -219,7 +198,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->remove_widget)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* CellEditable_Class::wrap_new(GObject* object)
@@ -264,17 +242,17 @@ GType CellEditable::get_base_type()
 
 void CellEditable::start_editing(GdkEvent* event)
 {
-gtk_cell_editable_start_editing(gobj(), event); 
+  gtk_cell_editable_start_editing(gobj(), event);
 }
 
 void CellEditable::editing_done()
 {
-gtk_cell_editable_editing_done(gobj()); 
+  gtk_cell_editable_editing_done(gobj());
 }
 
 void CellEditable::remove_widget()
 {
-gtk_cell_editable_remove_widget(gobj()); 
+  gtk_cell_editable_remove_widget(gobj());
 }
 
 
@@ -283,14 +261,12 @@ Glib::SignalProxy0< void > CellEditable::signal_editing_done()
   return Glib::SignalProxy0< void >(this, &CellEditable_signal_editing_done_info);
 }
 
-
 Glib::SignalProxy0< void > CellEditable::signal_remove_widget()
 {
   return Glib::SignalProxy0< void >(this, &CellEditable_signal_remove_widget_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::CellEditable::on_editing_done()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -301,6 +277,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->editing_done)
     (*base->editing_done)(gobj());
 }
+
 void Gtk::CellEditable::on_remove_widget()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -311,9 +288,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->remove_widget)
     (*base->remove_widget)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::CellEditable::start_editing_vfunc(GdkEvent* event) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -324,7 +300,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->start_editing)
     (*base->start_editing)(gobj(),event);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/celleditable.h b/libs/gtkmm2/gtk/gtkmm/celleditable.h
index 065f9101da..8d2bfdd6c5 100644
--- a/libs/gtkmm2/gtk/gtkmm/celleditable.h
+++ b/libs/gtkmm2/gtk/gtkmm/celleditable.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLEDITABLE_H
 #define _GTKMM_CELLEDITABLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -116,45 +115,27 @@ public:
   void remove_widget();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %editing_done()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_editing_done();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %remove_widget()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_remove_widget();
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void start_editing_vfunc(GdkEvent* event);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void start_editing_vfunc(GdkEvent* event);
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_editing_done();
   virtual void on_remove_widget();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -173,6 +154,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_CELLEDITABLE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/celllayout.cc b/libs/gtkmm2/gtk/gtkmm/celllayout.cc
index 15f10eb85a..474dea3e5b 100644
--- a/libs/gtkmm2/gtk/gtkmm/celllayout.cc
+++ b/libs/gtkmm2/gtk/gtkmm/celllayout.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/celllayout.h>
 #include <gtkmm/private/celllayout_p.h>
 
@@ -27,58 +26,75 @@
 #include <gtk/gtkcelllayout.h>
 
 
-static void SignalProxy_CellData_gtk_callback(GtkCellLayout* /* cell_layout */, GtkCellRenderer* /* cell */, GtkTreeModel* tree_model, GtkTreeIter* iter, gpointer data)
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_CellData
+{
+public:
+  typedef Gtk::CellLayout::SlotCellData SlotType;
+
+  SignalProxy_CellData(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_CellData();
+
+  static void gtk_callback(GtkCellLayout* cell_layout, GtkCellRenderer* cell, GtkTreeModel* tree_model, GtkTreeIter* iter, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_CellData::~SignalProxy_CellData()
+{}
+
+void SignalProxy_CellData::gtk_callback(GtkCellLayout* /* cell_layout */, GtkCellRenderer* /* cell */, GtkTreeModel* tree_model, GtkTreeIter* iter, gpointer data)
 {
-  Gtk::CellLayout::SlotCellData* the_slot = static_cast<Gtk::CellLayout::SlotCellData*>(data);
+  SignalProxy_CellData *const self = static_cast<SignalProxy_CellData*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     //We ignore the cell, because that was given as an argument to the connecting method, so the caller should know which one it is already.
     //And we ignore the tree_model because that can be obtained from the iter or from the CellLayout itself.
-    (*the_slot)(Gtk::TreeModel::const_iterator(tree_model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)(Gtk::TreeModel::const_iterator(tree_model, iter));
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+
 }
 
-static void SignalProxy_CellData_gtk_callback_destroy(void* data)
+void SignalProxy_CellData::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::CellLayout::SlotCellData*>(data);
+  delete static_cast<SignalProxy_CellData*>(data);
 }
 
+} // anonymous namespace
+
+
 namespace Gtk
 {
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 void CellLayout::add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column)
 {
   gtk_cell_layout_add_attribute(gobj(),
       (GtkCellRenderer*) property.get_object()->gobj(), property.get_name(), column.index());
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-void CellLayout::add_attribute(CellRenderer& cell, const Glib::ustring& attribute, const TreeModelColumnBase& column)
-{
-  gtk_cell_layout_add_attribute(gobj(),
-      (GtkCellRenderer*) cell.gobj(), attribute.c_str(), column.index());
-}
 
 void CellLayout::set_cell_data_func(CellRenderer& cell, const SlotCellData& slot)
 {
-  // Create a copy of the slot object.  A pointer to this will be passed
+  // Create a signal proxy.  A pointer to this will be passed
   // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_CellData_gtk_callback_destroy() is called.
-  SlotCellData* slot_copy = new SlotCellData(slot);
+  // when SignalProxy_CellData::gtk_callback_destroy() is called.
+  SignalProxy_CellData *const pSignalProxy = new SignalProxy_CellData(slot);
 
   gtk_cell_layout_set_cell_data_func(gobj(), cell.gobj(),
-      &SignalProxy_CellData_gtk_callback, slot_copy,
-      &SignalProxy_CellData_gtk_callback_destroy);
+      &SignalProxy_CellData::gtk_callback, pSignalProxy,
+      &SignalProxy_CellData::gtk_callback_destroy);
 }
   
 
@@ -131,20 +147,14 @@ void CellLayout_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->pack_start = &pack_start_vfunc_callback;
   klass->pack_end = &pack_end_vfunc_callback;
   klass->clear = &clear_vfunc_callback;
   klass->add_attribute = &add_attribute_vfunc_callback;
   klass->clear_attributes = &clear_attributes_vfunc_callback;
   klass->reorder = &reorder_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void CellLayout_Class::pack_start_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -157,21 +167,17 @@ void CellLayout_Class::pack_start_vfunc_callback(GtkCellLayout* self, GtkCellRen
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->pack_start_vfunc(Glib::wrap(cell)
 , expand
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -185,6 +191,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->pack_start)(self, cell, expand);
   }
 }
+
 void CellLayout_Class::pack_end_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -197,21 +204,17 @@ void CellLayout_Class::pack_end_vfunc_callback(GtkCellLayout* self, GtkCellRende
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->pack_end_vfunc(Glib::wrap(cell)
 , expand
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -225,6 +228,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->pack_end)(self, cell, expand);
   }
 }
+
 void CellLayout_Class::clear_vfunc_callback(GtkCellLayout* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -237,19 +241,15 @@ void CellLayout_Class::clear_vfunc_callback(GtkCellLayout* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->clear_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -263,6 +263,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->clear)(self);
   }
 }
+
 void CellLayout_Class::add_attribute_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, const gchar* attribute, gint column)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -275,22 +276,18 @@ void CellLayout_Class::add_attribute_vfunc_callback(GtkCellLayout* self, GtkCell
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->add_attribute_vfunc(Glib::wrap(cell)
 , Glib::convert_const_gchar_ptr_to_ustring(attribute)
 , column
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -304,6 +301,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->add_attribute)(self, cell, attribute, column);
   }
 }
+
 void CellLayout_Class::clear_attributes_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -316,20 +314,16 @@ void CellLayout_Class::clear_attributes_vfunc_callback(GtkCellLayout* self, GtkC
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->clear_attributes_vfunc(Glib::wrap(cell)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -343,6 +337,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->clear_attributes)(self, cell);
   }
 }
+
 void CellLayout_Class::reorder_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gint position)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -355,21 +350,17 @@ void CellLayout_Class::reorder_vfunc_callback(GtkCellLayout* self, GtkCellRender
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->reorder_vfunc(Glib::wrap(cell)
 , position
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -383,10 +374,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->reorder)(self, cell, position);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* CellLayout_Class::wrap_new(GObject* object)
@@ -431,39 +418,35 @@ GType CellLayout::get_base_type()
 
 void CellLayout::pack_start(CellRenderer& cell, bool expand)
 {
-gtk_cell_layout_pack_start(gobj(), (cell).gobj(), static_cast<int>(expand)); 
+  gtk_cell_layout_pack_start(gobj(), (cell).gobj(), static_cast<int>(expand));
 }
 
 void CellLayout::pack_end(CellRenderer& cell, bool expand)
 {
-gtk_cell_layout_pack_end(gobj(), (cell).gobj(), static_cast<int>(expand)); 
+  gtk_cell_layout_pack_end(gobj(), (cell).gobj(), static_cast<int>(expand));
 }
 
 void CellLayout::clear()
 {
-gtk_cell_layout_clear(gobj()); 
+  gtk_cell_layout_clear(gobj());
 }
 
 void CellLayout::add_attribute(CellRenderer& cell, const Glib::ustring& attribute, int column)
 {
-gtk_cell_layout_add_attribute(gobj(), (cell).gobj(), attribute.c_str(), column); 
+  gtk_cell_layout_add_attribute(gobj(), (cell).gobj(), attribute.c_str(), column);
 }
 
 void CellLayout::clear_attributes(CellRenderer& cell)
 {
-gtk_cell_layout_clear_attributes(gobj(), (cell).gobj()); 
+  gtk_cell_layout_clear_attributes(gobj(), (cell).gobj());
 }
 
 void CellLayout::reorder(CellRenderer& cell, int position)
 {
-gtk_cell_layout_reorder(gobj(), (cell).gobj(), position); 
+  gtk_cell_layout_reorder(gobj(), (cell).gobj(), position);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Gtk::CellLayout::pack_start_vfunc(CellRenderer* cell, bool expand) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -474,6 +457,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->pack_start)
     (*base->pack_start)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),static_cast<int>(expand));
 }
+
 void Gtk::CellLayout::pack_end_vfunc(CellRenderer* cell, bool expand) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -484,6 +468,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->pack_end)
     (*base->pack_end)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),static_cast<int>(expand));
 }
+
 void Gtk::CellLayout::clear_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -494,6 +479,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->clear)
     (*base->clear)(gobj());
 }
+
 void Gtk::CellLayout::add_attribute_vfunc(CellRenderer* cell, const Glib::ustring& attribute, int column) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -504,6 +490,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->add_attribute)
     (*base->add_attribute)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),attribute.c_str(),column);
 }
+
 void Gtk::CellLayout::clear_attributes_vfunc(CellRenderer* cell) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -514,6 +501,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->clear_attributes)
     (*base->clear_attributes)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell));
 }
+
 void Gtk::CellLayout::reorder_vfunc(CellRenderer* cell, int position) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -524,7 +512,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->reorder)
     (*base->reorder)(gobj(),(GtkCellRenderer*)Glib::unwrap(cell),position);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/celllayout.h b/libs/gtkmm2/gtk/gtkmm/celllayout.h
index 7a2484621f..1fc7c8f6eb 100644
--- a/libs/gtkmm2/gtk/gtkmm/celllayout.h
+++ b/libs/gtkmm2/gtk/gtkmm/celllayout.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLLAYOUT_H
 #define _GTKMM_CELLLAYOUT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -109,9 +108,7 @@ public:
    * then the @a cell  is allocated no more space than it needs. Any unused space
    * is divided evenly between cells for which @a expand  is <tt>true</tt>.
    * 
-   * Note that reusing the same cell renderer is not supported. 
-   * 
-   * @newin2p4
+   * Since: 2.4
    * @param cell A Gtk::CellRenderer.
    * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a cell_layout .
    */
@@ -121,9 +118,7 @@ public:
    *  @a cell  is allocated no more space than it needs. Any unused space is
    * divided evenly between cells for which @a expand  is <tt>true</tt>.
    * 
-   * Note that reusing the same cell renderer is not supported. 
-   * 
-   * @newin2p4
+   * Since: 2.4
    * @param cell A Gtk::CellRenderer.
    * @param expand <tt>true</tt> if @a cell  is to be given extra space allocated to @a cell_layout .
    */
@@ -132,10 +127,10 @@ public:
   /** Unsets all the mappings on all renderers on @a cell_layout  and
    * removes all renderers from @a cell_layout .
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void clear();
-
+  
    //I think this is just a convenience method, equivalent to clear() and multiple add_attribute()s. murrayc.
 
   
@@ -145,29 +140,24 @@ public:
    * of the model contains strings, you could have the "text" attribute of a
    * Gtk::CellRendererText get its values from column 2.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param cell A Gtk::CellRenderer.
    * @param attribute An attribute on the renderer.
    * @param column The column position on the model to get the attribute from.
    */
   void add_attribute(CellRenderer& cell, const Glib::ustring& attribute, int column);
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
   void add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column);
-#endif
 
-  void add_attribute(CellRenderer& cell, const Glib::ustring& attribute, const TreeModelColumnBase& column);
-
-  //For instance, void on_cell_data(const TreeModel::const_iterator& iter)
+  //For instance, void on_cell_data(const TreeModel::const_iterator& iter)                                        
   typedef sigc::slot<void, const TreeModel::const_iterator&> SlotCellData;
 
   void set_cell_data_func(CellRenderer& cell, const SlotCellData& slot);
   
-
+                                                                                  
   /** Clears all existing attributes previously set with
    * set_attributes().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param cell A Gtk::CellRenderer to clear the attribute mapping on.
    */
   void clear_attributes(CellRenderer& cell);
@@ -176,54 +166,31 @@ public:
   /** Re-inserts @a cell  at @a position . Note that @a cell  has already to be packed
    * into @a cell_layout  for this to function properly.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param cell A Gtk::CellRenderer to reorder.
    * @param position New position to insert @a cell  at.
    */
   void reorder(CellRenderer& cell, int position);
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void pack_start_vfunc(CellRenderer* cell, bool expand);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void pack_end_vfunc(CellRenderer* cell, bool expand);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void clear_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void add_attribute_vfunc(CellRenderer* cell, const Glib::ustring& attribute, int column);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void pack_start_vfunc(CellRenderer* cell, bool expand);
+    virtual void pack_end_vfunc(CellRenderer* cell, bool expand);
+    virtual void clear_vfunc();
+    virtual void add_attribute_vfunc(CellRenderer* cell, const Glib::ustring& attribute, int column);
 //TODO:  _WRAP_VFUNC(void set_cell_data_func(CellRenderer* cell, GtkCellLayoutDataFunc func, gpointer func_data, GDestroyNotify destroy), set_cell_data_func)
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void clear_attributes_vfunc(CellRenderer* cell);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void reorder_vfunc(CellRenderer* cell, int position);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void clear_attributes_vfunc(CellRenderer* cell);
+    virtual void reorder_vfunc(CellRenderer* cell, int position);
+                                 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -238,11 +205,7 @@ void CellLayout::pack_start(const TreeModelColumn<T_ModelColumnType>& column, bo
   pack_start(*pCellRenderer, expand);
 
   //Make the renderer render the column:
-#ifdef GLIBMM_PROPERTIES_ENABLED
   add_attribute(pCellRenderer->_property_renderable(), column);
-#else
-  add_attribute(*pCellRenderer, pCellRenderer->_property_renderable(), column);
-#endif
 }
 
 } // namespace Gtk
@@ -259,6 +222,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_CELLLAYOUT_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderer.cc
index 8ce803d02e..8cec8dc46f 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderer.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/cellrenderer.h>
 #include <gtkmm/private/cellrenderer_p.h>
 
@@ -35,19 +34,11 @@ void CellRenderer::get_size(Widget& widget, int& x_offset, int& y_offset, int& w
   gtk_cell_renderer_get_size(const_cast<GtkCellRenderer*>(gobj()), widget.gobj(), 0, &x_offset, &y_offset, &width, &height);
 }
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_Base CellRenderer::_property_renderable()
 {
   g_assert_not_reached();
   return Glib::PropertyProxy<int>(0, 0); // shut up warnings
 }
-#else
-Glib::ustring CellRenderer::_property_renderable()
-{
-  g_assert_not_reached();
-  return Glib::ustring();
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 } // namespace Gtk
 
@@ -55,8 +46,7 @@ Glib::ustring CellRenderer::_property_renderable()
 namespace
 {
 
-
-static const Glib::SignalProxyInfo CellRenderer_signal_editing_canceled_info =
+const Glib::SignalProxyInfo CellRenderer_signal_editing_canceled_info =
 {
   "editing_canceled",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -64,7 +54,7 @@ static const Glib::SignalProxyInfo CellRenderer_signal_editing_canceled_info =
 };
 
 
-static void CellRenderer_signal_editing_started_callback(GtkCellRenderer* self, GtkCellEditable* p0,const gchar* p1,void* data)
+void CellRenderer_signal_editing_started_callback(GtkCellRenderer* self, GtkCellEditable* p0,const gchar* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,CellEditable*,const Glib::ustring& > SlotType;
@@ -72,32 +62,27 @@ static void CellRenderer_signal_editing_started_callback(GtkCellRenderer* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(dynamic_cast<CellEditable*>(Glib::wrap_auto((GObject*)(p0), false))
 , Glib::convert_const_gchar_ptr_to_ustring(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo CellRenderer_signal_editing_started_info =
+const Glib::SignalProxyInfo CellRenderer_signal_editing_started_info =
 {
   "editing_started",
   (GCallback) &CellRenderer_signal_editing_started_callback,
   (GCallback) &CellRenderer_signal_editing_started_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -154,19 +139,13 @@ void CellRenderer_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_size = &get_size_vfunc_callback;
   klass->render = &render_vfunc_callback;
   klass->activate = &activate_vfunc_callback;
   klass->start_editing = &start_editing_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->editing_canceled = &editing_canceled_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void CellRenderer_Class::get_size_vfunc_callback(GtkCellRenderer* self, GtkWidget* widget, GdkRectangle* cell_area, gint* x_offset, gint* y_offset, gint* width, gint* height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -179,10 +158,8 @@ void CellRenderer_Class::get_size_vfunc_callback(GtkCellRenderer* self, GtkWidge
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_size_vfunc(*Glib::wrap(widget)
 , &Glib::wrap(cell_area)
@@ -191,13 +168,11 @@ void CellRenderer_Class::get_size_vfunc_callback(GtkCellRenderer* self, GtkWidge
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -210,6 +185,7 @@ void CellRenderer_Class::get_size_vfunc_callback(GtkCellRenderer* self, GtkWidge
       (*base->get_size)(self, widget, cell_area, x_offset, y_offset, width, height);
   }
 }
+
 void CellRenderer_Class::render_vfunc_callback(GtkCellRenderer* self, GdkDrawable* window, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GdkRectangle* expose_area, GtkCellRendererState flags)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -222,10 +198,8 @@ void CellRenderer_Class::render_vfunc_callback(GtkCellRenderer* self, GdkDrawabl
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->render_vfunc(Glib::wrap(window, true)
 , *Glib::wrap(widget)
@@ -234,13 +208,11 @@ void CellRenderer_Class::render_vfunc_callback(GtkCellRenderer* self, GdkDrawabl
 , Glib::wrap(expose_area)
 , ((CellRendererState)(flags))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -253,6 +225,7 @@ void CellRenderer_Class::render_vfunc_callback(GtkCellRenderer* self, GdkDrawabl
       (*base->render)(self, window, widget, background_area, cell_area, expose_area, flags);
   }
 }
+
 gboolean CellRenderer_Class::activate_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -265,10 +238,8 @@ gboolean CellRenderer_Class::activate_vfunc_callback(GtkCellRenderer* self, GdkE
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->activate_vfunc(event, *Glib::wrap(widget)
 , Glib::convert_const_gchar_ptr_to_ustring(path)
@@ -276,13 +247,11 @@ gboolean CellRenderer_Class::activate_vfunc_callback(GtkCellRenderer* self, GdkE
 , Glib::wrap(cell_area)
 , ((CellRendererState)(flags))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -298,6 +267,7 @@ gboolean CellRenderer_Class::activate_vfunc_callback(GtkCellRenderer* self, GdkE
   typedef gboolean RType;
   return RType();
 }
+
 GtkCellEditable* CellRenderer_Class::start_editing_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -308,12 +278,10 @@ GtkCellEditable* CellRenderer_Class::start_editing_vfunc_callback(GtkCellRendere
   // 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_())
+  if(false) //obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->start_editing_vfunc(event, *Glib::wrap(widget)
 , Glib::convert_const_gchar_ptr_to_ustring(path)
@@ -321,13 +289,11 @@ GtkCellEditable* CellRenderer_Class::start_editing_vfunc_callback(GtkCellRendere
 , Glib::wrap(cell_area)
 , ((CellRendererState)(flags))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -343,9 +309,8 @@ GtkCellEditable* CellRenderer_Class::start_editing_vfunc_callback(GtkCellRendere
   typedef GtkCellEditable* RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void CellRenderer_Class::editing_canceled_callback(GtkCellRenderer* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -358,19 +323,15 @@ void CellRenderer_Class::editing_canceled_callback(GtkCellRenderer* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_editing_canceled();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -383,7 +344,6 @@ void CellRenderer_Class::editing_canceled_callback(GtkCellRenderer* self)
       (*base->editing_canceled)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* CellRenderer_Class::wrap_new(GObject* o)
@@ -427,12 +387,12 @@ GType CellRenderer::get_base_type()
 
 void CellRenderer::get_size(Widget& widget, const Gdk::Rectangle& cell_area, int& x_offset, int& y_offset, int& width, int& height) const
 {
-gtk_cell_renderer_get_size(const_cast<GtkCellRenderer*>(gobj()), (widget).gobj(), const_cast<GdkRectangle*>(cell_area.gobj()), &x_offset, &y_offset, &width, &height); 
+  gtk_cell_renderer_get_size(const_cast<GtkCellRenderer*>(gobj()), (widget).gobj(), const_cast<GdkRectangle*>(cell_area.gobj()), &x_offset, &y_offset, &width, &height);
 }
 
 void CellRenderer::render(const Glib::RefPtr<Gdk::Window>& window, Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, CellRendererState flags)
 {
-gtk_cell_renderer_render(gobj(), Glib::unwrap(window), (widget).gobj(), const_cast<GdkRectangle*>(background_area.gobj()), const_cast<GdkRectangle*>(cell_area.gobj()), const_cast<GdkRectangle*>(expose_area.gobj()), ((GtkCellRendererState)(flags))); 
+  gtk_cell_renderer_render(gobj(), Glib::unwrap(window), (widget).gobj(), const_cast<GdkRectangle*>(background_area.gobj()), const_cast<GdkRectangle*>(cell_area.gobj()), const_cast<GdkRectangle*>(expose_area.gobj()), ((GtkCellRendererState)(flags)));
 }
 
 bool CellRenderer::activate(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags)
@@ -447,26 +407,22 @@ CellEditable* CellRenderer::start_editing(GdkEvent* event, Widget& widget, const
 
 void CellRenderer::set_fixed_size(int width, int height)
 {
-gtk_cell_renderer_set_fixed_size(gobj(), width, height); 
+  gtk_cell_renderer_set_fixed_size(gobj(), width, height);
 }
 
 void CellRenderer::get_fixed_size(int& width, int& height) const
 {
-gtk_cell_renderer_get_fixed_size(const_cast<GtkCellRenderer*>(gobj()), &width, &height); 
+  gtk_cell_renderer_get_fixed_size(const_cast<GtkCellRenderer*>(gobj()), &width, &height);
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void CellRenderer::editing_canceled()
 {
-gtk_cell_renderer_editing_canceled(gobj()); 
+  gtk_cell_renderer_editing_canceled(gobj());
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 void CellRenderer::stop_editing(bool canceled)
 {
-gtk_cell_renderer_stop_editing(gobj(), static_cast<int>(canceled)); 
+  gtk_cell_renderer_stop_editing(gobj(), static_cast<int>(canceled));
 }
 
 CellRenderer::CellRenderer()
@@ -482,204 +438,143 @@ Glib::SignalProxy0< void > CellRenderer::signal_editing_canceled()
   return Glib::SignalProxy0< void >(this, &CellRenderer_signal_editing_canceled_info);
 }
 
-
 Glib::SignalProxy2< void,CellEditable*,const Glib::ustring& > CellRenderer::signal_editing_started()
 {
   return Glib::SignalProxy2< void,CellEditable*,const Glib::ustring& >(this, &CellRenderer_signal_editing_started_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<CellRendererMode> CellRenderer::property_mode() 
 {
   return Glib::PropertyProxy<CellRendererMode>(this, "mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<CellRendererMode> CellRenderer::property_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<CellRendererMode>(this, "mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRenderer::property_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> CellRenderer::property_sensitive() 
-{
-  return Glib::PropertyProxy<bool>(this, "sensitive");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_sensitive() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "sensitive");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> CellRenderer::property_xalign() 
 {
   return Glib::PropertyProxy<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> CellRenderer::property_xalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> CellRenderer::property_yalign() 
 {
   return Glib::PropertyProxy<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> CellRenderer::property_yalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<unsigned int> CellRenderer::property_xpad() 
 {
   return Glib::PropertyProxy<unsigned int>(this, "xpad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<unsigned int> CellRenderer::property_xpad() const
 {
   return Glib::PropertyProxy_ReadOnly<unsigned int>(this, "xpad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<unsigned int> CellRenderer::property_ypad() 
 {
   return Glib::PropertyProxy<unsigned int>(this, "ypad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<unsigned int> CellRenderer::property_ypad() const
 {
   return Glib::PropertyProxy_ReadOnly<unsigned int>(this, "ypad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> CellRenderer::property_width() 
 {
   return Glib::PropertyProxy<int>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> CellRenderer::property_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> CellRenderer::property_height() 
 {
   return Glib::PropertyProxy<int>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> CellRenderer::property_height() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRenderer::property_is_expander() 
 {
   return Glib::PropertyProxy<bool>(this, "is-expander");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_is_expander() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "is-expander");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRenderer::property_is_expanded() 
 {
   return Glib::PropertyProxy<bool>(this, "is-expanded");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_is_expanded() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "is-expanded");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRenderer::property_cell_background() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "cell-background");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRenderer::property_cell_background() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "cell-background");
+}
+
 Glib::PropertyProxy<Gdk::Color> CellRenderer::property_cell_background_gdk() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "cell-background-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRenderer::property_cell_background_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "cell-background-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRenderer::property_cell_background_set() 
 {
   return Glib::PropertyProxy<bool>(this, "cell-background-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRenderer::property_cell_background_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "cell-background-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::CellRenderer::on_editing_canceled()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -689,9 +584,8 @@ void Gtk::CellRenderer::on_editing_canceled()
   if(base && base->editing_canceled)
     (*base->editing_canceled)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::CellRenderer::get_size_vfunc(Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -701,6 +595,7 @@ void Gtk::CellRenderer::get_size_vfunc(Widget& widget, const Gdk::Rectangle* cel
   if(base && base->get_size)
     (*base->get_size)(const_cast<GtkCellRenderer*>(gobj()),(widget).gobj(),Glib::unwrap(const_cast<Gdk::Rectangle*>(cell_area)),x_offset,y_offset,width,height);
 }
+
 void Gtk::CellRenderer::render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window, Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, CellRendererState flags) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -710,6 +605,7 @@ void Gtk::CellRenderer::render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window,
   if(base && base->render)
     (*base->render)(gobj(),Glib::unwrap(window),(widget).gobj(),const_cast<GdkRectangle*>(background_area.gobj()),const_cast<GdkRectangle*>(cell_area.gobj()),const_cast<GdkRectangle*>(expose_area.gobj()),((GtkCellRendererState)(flags)));
 }
+
 bool Gtk::CellRenderer::activate_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -722,6 +618,7 @@ bool Gtk::CellRenderer::activate_vfunc(GdkEvent* event, Widget& widget, const Gl
   typedef bool RType;
   return RType();
 }
+
 CellEditable* Gtk::CellRenderer::start_editing_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -734,7 +631,6 @@ CellEditable* Gtk::CellRenderer::start_editing_vfunc(GdkEvent* event, Widget& wi
   typedef CellEditable* RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer.h b/libs/gtkmm2/gtk/gtkmm/cellrenderer.h
index 95a2d4e616..7c382c44c5 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderer.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLRENDERER_H
 #define _GTKMM_CELLRENDERER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -196,18 +195,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_editing_canceled();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -321,28 +314,25 @@ public:
    */
   void get_fixed_size(int& width, int& height) const;
 
+  //TODO: Mark as @deprecated: See stop_editing().
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
   /** Causes the cell renderer to emit the "editing-canceled" signal.  This
    * function is for use only by implementations of cell renderers that need to
    * notify the client program that an editing process was canceled and the
    * changes were not committed.
    * 
-   * @newin2p4
+   * Since: 2.4
    * Deprecated: Use stop_editing() instead
-   * @deprecated Use stop_editing().
    */
   void editing_canceled();
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
+  
   /** Informs the cell renderer that the editing is stopped.
    * If @a canceled  is <tt>true</tt>, the cell renderer will emit the "editing-canceled" 
    * signal. This function should be called by cell renderer implementations 
    * in response to the "editing-done" signal of Gtk::CellEditable.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param canceled <tt>true</tt> if the editing has been canceled.
    */
   void stop_editing(bool canceled = false);
@@ -351,68 +341,27 @@ public:
    * For instance, property_text for CellRendererText, and property_active for CellRendererToggle
    * Needs to be overridden in derived classes.
    */
-#ifdef GLIBMM_PROPERTIES_ENABLED
   virtual Glib::PropertyProxy_Base _property_renderable();
-#else
-  virtual Glib::ustring _property_renderable();
-#endif
 
-  /** This signal is emitted when the user cancels the process of editing a
-   * cell.  For example, an editable cell renderer could be written to cancel
-   * editing when the user presses Escape. 
-   *
-   * @see editing_canceled() 
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %editing_canceled()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_editing_canceled();
 
   
   //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
   //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
-  //TODO: Remove the warning in the documentation when we have fixed the inheritance of CellRendererCombo.
-  /** This signal gets emitted when a cell starts to be edited.
-   * The indended use of this signal is to do special setup
-   * on @a editable, e.g. adding an EntryCompletion or setting
-   * up additional columns in a ComboBox.
-   *
-   * Note that GTK+ doesn't guarantee that cell renderers will
-   * continue to use the same kind of widget for editing in future
-   * releases, therefore you should check the type of @a editable
-   * before doing any specific setup.
-   *
-   * Note that this signal does not work yet in gtkmm.
-   * See http://bugzilla.gnome.org/show_bug.cgi?id=301597
-   *
-   * @newin2p6
-   *
-   * @param editable the CellEditable.
-   * @param path the path identifying the edited cell.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %editing_started(CellEditable* editable, const Glib::ustring& path)</tt>
-   */
 
   Glib::SignalProxy2< void,CellEditable*,const Glib::ustring& > signal_editing_started();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Editable mode of the CellRenderer.
+  /** Editable mode of the CellRenderer.
    *
    * 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<CellRendererMode> property_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Editable mode of the CellRenderer.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -420,19 +369,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<CellRendererMode> property_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Display the cell.
+  /** Display the cell.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Display the cell.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -440,39 +385,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Display the cell sensitive.
-   *
-   * 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_sensitive() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Display the cell sensitive.
-   *
-   * 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_sensitive() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The x-align.
+  /** The x-align.
    *
    * 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<float> property_xalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The x-align.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -480,19 +401,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The y-align.
+  /** The y-align.
    *
    * 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<float> property_yalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The y-align.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -500,19 +417,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The xpad.
+  /** The xpad.
    *
    * 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<unsigned int> property_xpad() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The xpad.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -520,19 +433,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<unsigned int> property_xpad() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The ypad.
+  /** The ypad.
    *
    * 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<unsigned int> property_ypad() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The ypad.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -540,19 +449,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<unsigned int> property_ypad() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The fixed width.
+  /** The fixed 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<int> property_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The fixed width.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -560,19 +465,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The fixed height.
+  /** The fixed 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<int> property_height() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The fixed height.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -580,19 +481,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Row has children.
+  /** Row has children.
    *
    * 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_is_expander() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Row has children.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -600,19 +497,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_is_expander() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Row is an expander row
+  /** Row is an expander row
    *
    * 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_is_expanded() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Row is an expander row
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -620,30 +513,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_is_expanded() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Cell background color as a string.
+  /** Cell background color as a string.
    *
    * 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_cell_background() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
+/** Cell background color as a string.
+   *
+   * 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_cell_background() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Cell background color as a GdkColor.
+  /** Cell background color as a GdkColor.
    *
    * 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_cell_background_gdk() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Cell background color as a GdkColor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -651,19 +545,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_cell_background_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
  
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the cell background color.
+  /** Whether this tag affects the cell background 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<bool> property_cell_background_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the cell background color.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -671,7 +561,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_cell_background_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -693,24 +582,14 @@ protected:
    * @param width Width needed to render a cell.
    * @param height Height needed to render a cell.
    **/
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_size_vfunc(Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void get_size_vfunc(Widget& widget, const Gdk::Rectangle* cell_area, int* x_offset, int* y_offset, int* width, int* height) const;
                   
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window, Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, CellRendererState flags);
-#endif //GLIBMM_VFUNCS_ENABLED
 
+    virtual void render_vfunc(const Glib::RefPtr<Gdk::Drawable>& window, Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, CellRendererState flags);
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool activate_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual bool activate_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags);
 
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual CellEditable* start_editing_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual CellEditable* start_editing_vfunc(GdkEvent* event, Widget& widget, const Glib::ustring& path, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, CellRendererState flags);
 
 
 };
@@ -726,8 +605,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CellRenderer* wrap(GtkCellRenderer* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CELLRENDERER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.cc
index c100037431..fc5a69c6bd 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.cc
@@ -41,26 +41,7 @@ CellRenderer* generate_cellrenderer<bool>(bool editable)
   CellRendererToggle* pCellRenderer = new CellRendererToggle();
 
   //GTK+'s "activatable" really means "editable":
-#ifdef GLIBMM_PROPERTIES_ENABLED
   pCellRenderer->property_activatable() = editable;
-#else
-  pCellRenderer->set_property("activatable", editable);
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-  return pCellRenderer;
-}
-
-template<>
-CellRenderer* generate_cellrenderer<AccelKey>(bool editable)
-{
-  CellRendererAccel* pCellRenderer = new CellRendererAccel();
-
-  //GTK+'s "editable" really means "editable":
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  pCellRenderer->property_editable() = editable;
-#else
-  pCellRenderer->set_property("editable", editable);
-#endif //GLIBMM_PROPERTIES_ENABLED
 
   return pCellRenderer;
 }
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.h b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.h
index 8c8cc2924a..309fba4b07 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderer_generation.h
@@ -24,7 +24,6 @@
 #include <gtkmm/cellrenderertext.h>
 #include <gtkmm/cellrendererpixbuf.h>
 #include <gtkmm/cellrenderertoggle.h>
-#include <gtkmm/cellrendereraccel.h>
 
 namespace Gtk
 {
@@ -39,12 +38,7 @@ CellRenderer* generate_cellrenderer(bool editable = false)
   CellRendererText* pCellRenderer = new CellRendererText(); //the default - template specializations will use other renderers.
   //CellRendererText can render both strings and numerical values.
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
   pCellRenderer->property_editable() = editable;
-#else
-  pCellRenderer->set_property("editable", editable);
-#endif
-
   return pCellRenderer;
 }
 
@@ -57,9 +51,6 @@ CellRenderer* generate_cellrenderer<bool>(bool editable);
 template<>
 CellRenderer* generate_cellrenderer< Glib::RefPtr<Gdk::Pixbuf> >(bool editable);
 
-template<>
-CellRenderer* generate_cellrenderer<AccelKey>(bool editable);
-
 #endif
 
 } //CellRenderer_Generation
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendereraccel.cc b/libs/gtkmm2/gtk/gtkmm/cellrendereraccel.cc
deleted file mode 100644
index 0e10e4d80f..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/cellrendereraccel.cc
+++ /dev/null
@@ -1,381 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/cellrendereraccel.h>
-#include <gtkmm/private/cellrendereraccel_p.h>
-
-// -*- c++ -*-
-/* $Id: cellrendereraccel.ccg,v 1.2 2006/05/11 11:40:24 murrayc Exp $ */
-
-/* 
- *
- * Copyright 2005 The gtkmm 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 <gtk/gtkcellrendereraccel.h>
-
-namespace Gtk
-{
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_Base CellRendererAccel::_property_renderable()
-{
-  //Renderering just this one property would probably not be meaningful.
-  return property_accel_key();
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-} //namespace Gtk
-
-namespace
-{
-
-
-static void CellRendererAccel_signal_accel_edited_callback(GtkCellRendererAccel* self, const gchar* p0,guint p1,GdkModifierType p2,guint p3,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::ustring&,guint,Gdk::ModifierType,guint > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
-, p1, ((Gdk::ModifierType)(p2))
-, p3);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo CellRendererAccel_signal_accel_edited_info =
-{
-  "accel_edited",
-  (GCallback) &CellRendererAccel_signal_accel_edited_callback,
-  (GCallback) &CellRendererAccel_signal_accel_edited_callback
-};
-
-
-static void CellRendererAccel_signal_accel_cleared_callback(GtkCellRendererAccel* self, const gchar* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::ustring& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo CellRendererAccel_signal_accel_cleared_info =
-{
-  "accel_cleared",
-  (GCallback) &CellRendererAccel_signal_accel_cleared_callback,
-  (GCallback) &CellRendererAccel_signal_accel_cleared_callback
-};
-
-
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::CellRendererAccel* wrap(GtkCellRendererAccel* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::CellRendererAccel *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& CellRendererAccel_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_ = &CellRendererAccel_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(gtk_cell_renderer_accel_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void CellRendererAccel_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->accel_edited = &accel_edited_callback;
-  klass->accel_cleared = &accel_cleared_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void CellRendererAccel_Class::accel_edited_callback(GtkCellRendererAccel* self, const gchar* p0, guint p1, GdkModifierType p2, guint p3)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_accel_edited(Glib::convert_const_gchar_ptr_to_ustring(p0)
-, p1, ((Gdk::ModifierType)(p2))
-, p3);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->accel_edited)
-      (*base->accel_edited)(self, p0, p1, p2, p3);
-  }
-}
-void CellRendererAccel_Class::accel_cleared_callback(GtkCellRendererAccel* self, const gchar* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_accel_cleared(Glib::convert_const_gchar_ptr_to_ustring(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->accel_cleared)
-      (*base->accel_cleared)(self, p0);
-  }
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* CellRendererAccel_Class::wrap_new(GObject* o)
-{
-  return manage(new CellRendererAccel((GtkCellRendererAccel*)(o)));
-
-}
-
-
-/* The implementation: */
-
-CellRendererAccel::CellRendererAccel(const Glib::ConstructParams& construct_params)
-:
-  Gtk::CellRendererText(construct_params)
-{
-  }
-
-CellRendererAccel::CellRendererAccel(GtkCellRendererAccel* castitem)
-:
-  Gtk::CellRendererText((GtkCellRendererText*)(castitem))
-{
-  }
-
-CellRendererAccel::~CellRendererAccel()
-{
-  destroy_();
-}
-
-CellRendererAccel::CppClassType CellRendererAccel::cellrendereraccel_class_; // initialize static member
-
-GType CellRendererAccel::get_type()
-{
-  return cellrendereraccel_class_.init().get_type();
-}
-
-GType CellRendererAccel::get_base_type()
-{
-  return gtk_cell_renderer_accel_get_type();
-}
-
-
-CellRendererAccel::CellRendererAccel()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::CellRendererText(Glib::ConstructParams(cellrendereraccel_class_.init()))
-{
-  }
-
-
-Glib::SignalProxy4< void,const Glib::ustring&,guint,Gdk::ModifierType,guint > CellRendererAccel::signal_accel_edited()
-{
-  return Glib::SignalProxy4< void,const Glib::ustring&,guint,Gdk::ModifierType,guint >(this, &CellRendererAccel_signal_accel_edited_info);
-}
-
-
-Glib::SignalProxy1< void,const Glib::ustring& > CellRendererAccel::signal_accel_cleared()
-{
-  return Glib::SignalProxy1< void,const Glib::ustring& >(this, &CellRendererAccel_signal_accel_cleared_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<guint> CellRendererAccel::property_accel_key() 
-{
-  return Glib::PropertyProxy<guint>(this, "accel-key");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<guint> CellRendererAccel::property_accel_key() const
-{
-  return Glib::PropertyProxy_ReadOnly<guint>(this, "accel-key");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Gdk::ModifierType> CellRendererAccel::property_accel_mods() 
-{
-  return Glib::PropertyProxy<Gdk::ModifierType>(this, "accel-mods");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Gdk::ModifierType> CellRendererAccel::property_accel_mods() const
-{
-  return Glib::PropertyProxy_ReadOnly<Gdk::ModifierType>(this, "accel-mods");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<guint> CellRendererAccel::property_keycode() 
-{
-  return Glib::PropertyProxy<guint>(this, "keycode");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<guint> CellRendererAccel::property_keycode() const
-{
-  return Glib::PropertyProxy_ReadOnly<guint>(this, "keycode");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Gtk::CellRendererAccel::on_accel_edited(const Glib::ustring& path_string, guint accel_key, Gdk::ModifierType accel_mods, guint hardware_keycode)
-{
-  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->accel_edited)
-    (*base->accel_edited)(gobj(),path_string.c_str(),accel_key,((GdkModifierType)(accel_mods)),hardware_keycode);
-}
-void Gtk::CellRendererAccel::on_accel_cleared(const Glib::ustring& path_string)
-{
-  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->accel_cleared)
-    (*base->accel_cleared)(gobj(),path_string.c_str());
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendereraccel.h b/libs/gtkmm2/gtk/gtkmm/cellrendereraccel.h
deleted file mode 100644
index 075be99c45..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/cellrendereraccel.h
+++ /dev/null
@@ -1,217 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_CELLRENDERERACCEL_H
-#define _GTKMM_CELLRENDERERACCEL_H
-
-
-#include <glibmm.h>
-
-/* $Id: cellrendereraccel.hg,v 1.2 2006/05/11 11:40:24 murrayc Exp $ */
-
-/* cellrendereraccel.h
- * 
- * Copyright (C) 2005 The gtkmm 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/cellrenderertext.h>
-#include <gtkmm/accelkey.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkCellRendererAccel GtkCellRendererAccel;
-typedef struct _GtkCellRendererAccelClass GtkCellRendererAccelClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class CellRendererAccel_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/**  .
- * TODO.
- *
- * @ingroup TreeView
- * @newin2p10
- */
-
-class CellRendererAccel : public CellRendererText
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef CellRendererAccel CppObjectType;
-  typedef CellRendererAccel_Class CppClassType;
-  typedef GtkCellRendererAccel BaseObjectType;
-  typedef GtkCellRendererAccelClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~CellRendererAccel();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class CellRendererAccel_Class;
-  static CppClassType cellrendereraccel_class_;
-
-  // noncopyable
-  CellRendererAccel(const CellRendererAccel&);
-  CellRendererAccel& operator=(const CellRendererAccel&);
-
-protected:
-  explicit CellRendererAccel(const Glib::ConstructParams& construct_params);
-  explicit CellRendererAccel(GtkCellRendererAccel* 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.
-  GtkCellRendererAccel*       gobj()       { return reinterpret_cast<GtkCellRendererAccel*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkCellRendererAccel* gobj() const { return reinterpret_cast<GtkCellRendererAccel*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual void on_accel_edited(const Glib::ustring& path_string, guint accel_key, Gdk::ModifierType accel_mods, guint hardware_keycode);
-  virtual void on_accel_cleared(const Glib::ustring& path_string);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-public:
-
-  CellRendererAccel();
-
-  //TODO: Wrap accel_key and accel_mods in an AccelKey?
-  
-/**
-   * @par Prototype:
-   * <tt>void %accel_edited(const Glib::ustring& path_string, guint accel_key, Gdk::ModifierType accel_mods, guint hardware_keycode)</tt>
-   */
-
-  Glib::SignalProxy4< void,const Glib::ustring&,guint,Gdk::ModifierType,guint > signal_accel_edited();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %accel_cleared(const Glib::ustring& path_string)</tt>
-   */
-
-  Glib::SignalProxy1< void,const Glib::ustring& > signal_accel_cleared();
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The keyval of the accelerator.
-   *
-   * 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_accel_key() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The keyval of the accelerator.
-   *
-   * 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_accel_key() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The modifier mask of the accelerator.
-   *
-   * 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::ModifierType> property_accel_mods() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The modifier mask of the accelerator.
-   *
-   * 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::ModifierType> property_accel_mods() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The hardware keycode of the accelerator.
-   *
-   * 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_keycode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The hardware keycode of the accelerator.
-   *
-   * 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_keycode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  virtual Glib::PropertyProxy_Base _property_renderable(); //override
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-};
-
-} /* namespace Gtk */
-
-
-namespace Glib
-{
-  /** @relates Gtk::CellRendererAccel
-   * @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.
-   */
-  Gtk::CellRendererAccel* wrap(GtkCellRendererAccel* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_CELLRENDERERACCEL_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.cc
index aa4771f28b..7570da7fa1 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/cellrenderercombo.h>
 #include <gtkmm/private/cellrenderercombo_p.h>
 
@@ -31,20 +30,14 @@
 namespace Gtk
 {
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_Base CellRendererCombo::_property_renderable()
 {
   return CellRendererText::_property_renderable();
 }
-#else
-Glib::ustring CellRendererCombo::_property_renderable()
-{
-  return CellRendererText::_property_renderable();
-}
-#endif //#ifdef GLIBMM_PROPERTIES_ENABLED
 
 } //namespace Gtk
 
+
 namespace
 {
 } // anonymous namespace
@@ -91,19 +84,8 @@ void CellRendererCombo_Class::class_init_function(void* g_class, void* class_dat
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* CellRendererCombo_Class::wrap_new(GObject* o)
 {
@@ -152,54 +134,35 @@ CellRendererCombo::CellRendererCombo()
   }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gtk::TreeModel> > CellRendererCombo::property_model() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gtk::TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> > CellRendererCombo::property_model() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> CellRendererCombo::property_text_column() 
 {
   return Glib::PropertyProxy<int>(this, "text-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> CellRendererCombo::property_text_column() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "text-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererCombo::property_has_entry() 
 {
   return Glib::PropertyProxy<bool>(this, "has-entry");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererCombo::property_has_entry() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-entry");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.h b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.h
index 8dc0250e66..7e158bd106 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderercombo.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLRENDERERCOMBO_H
 #define _GTKMM_CELLRENDERERCOMBO_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -98,17 +97,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -117,17 +110,14 @@ public:
 
   CellRendererCombo();
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The model containing the possible values for the combo box.
+  /** The model containing the possible values for the combo box.
    *
    * 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<Gtk::TreeModel> > property_model() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The model containing the possible values for the combo box.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -135,19 +125,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> > property_model() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A column in the data source model to get the strings from.
+  /** A column in the data source model to get the strings from.
    *
    * 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_text_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A column in the data source model to get the strings from.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -155,19 +141,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_text_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If FALSE
+  /** If FALSE
    *
    * 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_has_entry() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If FALSE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -175,14 +157,9 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_entry() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  virtual Glib::PropertyProxy_Base _property_renderable();
-#else
-  virtual Glib::ustring _property_renderable();
-#endif
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
 
 
 };
@@ -198,8 +175,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CellRendererCombo* wrap(GtkCellRendererCombo* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CELLRENDERERCOMBO_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.cc b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.cc
index 82ab381c6c..bbf363d011 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/cellrendererpixbuf.h>
 #include <gtkmm/private/cellrendererpixbuf_p.h>
 
@@ -30,20 +29,14 @@
 namespace Gtk
 {
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_Base CellRendererPixbuf::_property_renderable()
 {
   return property_pixbuf();
 }
-#else
-Glib::ustring CellRendererPixbuf::_property_renderable()
-{
-  return "pixbuf";
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 } //namespace Gtk
 
+
 namespace
 {
 } // anonymous namespace
@@ -90,19 +83,8 @@ void CellRendererPixbuf_Class::class_init_function(void* g_class, void* class_da
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* CellRendererPixbuf_Class::wrap_new(GObject* o)
 {
@@ -151,96 +133,65 @@ CellRendererPixbuf::CellRendererPixbuf()
   }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_open() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-open");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_open() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-open");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_closed() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-closed");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > CellRendererPixbuf::property_pixbuf_expander_closed() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf-expander-closed");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> CellRendererPixbuf::property_stock_id() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "stock-id");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererPixbuf::property_stock_id() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock-id");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> CellRendererPixbuf::property_stock_size() 
 {
   return Glib::PropertyProxy<guint>(this, "stock-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> CellRendererPixbuf::property_stock_size() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "stock-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> CellRendererPixbuf::property_stock_detail() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "stock-detail");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererPixbuf::property_stock_detail() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock-detail");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.h b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.h
index b9cb844d7d..8380c76492 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererpixbuf.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLRENDERERPIXBUF_H
 #define _GTKMM_CELLRENDERERPIXBUF_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,17 +95,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -114,18 +107,15 @@ private:
 public:
 
   CellRendererPixbuf();
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The pixbuf to render.
+  
+  /** The pixbuf to render.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The pixbuf to render.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -133,19 +123,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixbuf for open expander.
+  /** Pixbuf for open expander.
    *
    * 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_expander_open() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixbuf for open expander.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -153,19 +139,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_expander_open() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixbuf for closed expander.
+  /** Pixbuf for closed expander.
    *
    * 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_expander_closed() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixbuf for closed expander.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -173,19 +155,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_expander_closed() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The stock ID of the stock icon to render.
+  /** The stock ID of the stock icon to render.
    *
    * 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_stock_id() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The stock ID of the stock icon to render.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -193,19 +171,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock_id() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkIconSize value that specifies the size of the rendered icon.
+  /** The GtkIconSize value that specifies the size of the rendered icon.
    *
    * 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_stock_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkIconSize value that specifies the size of the rendered icon.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -213,19 +187,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_stock_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Render detail to pass to the theme engine.
+  /** Render detail to pass to the theme engine.
    *
    * 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_stock_detail() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Render detail to pass to the theme engine.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -233,14 +203,9 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock_detail() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  virtual Glib::PropertyProxy_Base _property_renderable();
-#else
-  virtual Glib::ustring _property_renderable();
-#endif
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
 
 
 };
@@ -256,8 +221,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CellRendererPixbuf* wrap(GtkCellRendererPixbuf* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CELLRENDERERPIXBUF_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.cc b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.cc
index 87795f7db1..e3f3b0ed4f 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/cellrendererprogress.h>
 #include <gtkmm/private/cellrendererprogress_p.h>
 
@@ -31,17 +30,10 @@
 namespace Gtk
 {
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_Base CellRendererProgress::_property_renderable()
 {
   return _property_renderable();
 }
-#else
-Glib::ustring CellRendererProgress::_property_renderable()
-{
-  return _property_renderable();
-}
-#endif //#ifdef GLIBMM_PROPERTIES_ENABLED
 
 
 } // namespace Gtk
@@ -93,19 +85,8 @@ void CellRendererProgress_Class::class_init_function(void* g_class, void* class_
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* CellRendererProgress_Class::wrap_new(GObject* o)
 {
@@ -154,40 +135,25 @@ CellRendererProgress::CellRendererProgress()
   }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> CellRendererProgress::property_value() 
 {
   return Glib::PropertyProxy<int>(this, "value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> CellRendererProgress::property_value() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> CellRendererProgress::property_text() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererProgress::property_text() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.h b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.h
index 1316e177d5..7ad6132715 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellrendererprogress.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLRENDERERPROGRESS_H
 #define _GTKMM_CELLRENDERERPROGRESS_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -87,17 +86,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -105,17 +98,14 @@ private:
 public:
   CellRendererProgress();
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Value of the progress bar.
+  /** Value of the progress bar.
    *
    * 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_value() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Value of the progress bar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -123,19 +113,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_value() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text on the progress bar.
+  /** Text on the progress bar.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text on the progress bar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -143,14 +129,9 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  virtual Glib::PropertyProxy_Base _property_renderable();
-#else
-  virtual Glib::ustring _property_renderable();
-#endif
+  
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
 
 
 };
@@ -166,8 +147,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CellRendererProgress* wrap(GtkCellRendererProgress* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CELLRENDERERPROGRESS_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererspin.cc b/libs/gtkmm2/gtk/gtkmm/cellrendererspin.cc
deleted file mode 100644
index 396686d536..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/cellrendererspin.cc
+++ /dev/null
@@ -1,197 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/cellrendererspin.h>
-#include <gtkmm/private/cellrendererspin_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkcellrendererspin.h>
-
-namespace Gtk
-{
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_Base CellRendererSpin::_property_renderable()
-{
-  return CellRendererText::_property_renderable();
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-} //namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::CellRendererSpin* wrap(GtkCellRendererSpin* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::CellRendererSpin *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& CellRendererSpin_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_ = &CellRendererSpin_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(gtk_cell_renderer_spin_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void CellRendererSpin_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* CellRendererSpin_Class::wrap_new(GObject* o)
-{
-  return manage(new CellRendererSpin((GtkCellRendererSpin*)(o)));
-
-}
-
-
-/* The implementation: */
-
-CellRendererSpin::CellRendererSpin(const Glib::ConstructParams& construct_params)
-:
-  Gtk::CellRendererText(construct_params)
-{
-  }
-
-CellRendererSpin::CellRendererSpin(GtkCellRendererSpin* castitem)
-:
-  Gtk::CellRendererText((GtkCellRendererText*)(castitem))
-{
-  }
-
-CellRendererSpin::~CellRendererSpin()
-{
-  destroy_();
-}
-
-CellRendererSpin::CppClassType CellRendererSpin::cellrendererspin_class_; // initialize static member
-
-GType CellRendererSpin::get_type()
-{
-  return cellrendererspin_class_.init().get_type();
-}
-
-GType CellRendererSpin::get_base_type()
-{
-  return gtk_cell_renderer_spin_get_type();
-}
-
-
-CellRendererSpin::CellRendererSpin()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::CellRendererText(Glib::ConstructParams(cellrendererspin_class_.init()))
-{
-  }
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Gtk::Adjustment*> CellRendererSpin::property_adjustment() 
-{
-  return Glib::PropertyProxy<Gtk::Adjustment*>(this, "adjustment");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> CellRendererSpin::property_adjustment() const
-{
-  return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "adjustment");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<double> CellRendererSpin::property_climb_rate() 
-{
-  return Glib::PropertyProxy<double>(this, "climb-rate");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<double> CellRendererSpin::property_climb_rate() const
-{
-  return Glib::PropertyProxy_ReadOnly<double>(this, "climb-rate");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<guint> CellRendererSpin::property_digits() 
-{
-  return Glib::PropertyProxy<guint>(this, "digits");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<guint> CellRendererSpin::property_digits() const
-{
-  return Glib::PropertyProxy_ReadOnly<guint>(this, "digits");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrendererspin.h b/libs/gtkmm2/gtk/gtkmm/cellrendererspin.h
deleted file mode 100644
index 45dc03709b..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/cellrendererspin.h
+++ /dev/null
@@ -1,191 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_CELLRENDERERSPIN_H
-#define _GTKMM_CELLRENDERERSPIN_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/cellrenderertext.h>
-//#include <gtkmm/treemodel.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkCellRendererSpin GtkCellRendererSpin;
-typedef struct _GtkCellRendererSpinClass GtkCellRendererSpinClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class CellRendererSpin_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/**  TODO. 
- *
- * @ingroup TreeView
- */
-
-class CellRendererSpin : public CellRendererText
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef CellRendererSpin CppObjectType;
-  typedef CellRendererSpin_Class CppClassType;
-  typedef GtkCellRendererSpin BaseObjectType;
-  typedef GtkCellRendererSpinClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~CellRendererSpin();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class CellRendererSpin_Class;
-  static CppClassType cellrendererspin_class_;
-
-  // noncopyable
-  CellRendererSpin(const CellRendererSpin&);
-  CellRendererSpin& operator=(const CellRendererSpin&);
-
-protected:
-  explicit CellRendererSpin(const Glib::ConstructParams& construct_params);
-  explicit CellRendererSpin(GtkCellRendererSpin* 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.
-  GtkCellRendererSpin*       gobj()       { return reinterpret_cast<GtkCellRendererSpin*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkCellRendererSpin* gobj() const { return reinterpret_cast<GtkCellRendererSpin*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-public:
-
-  CellRendererSpin();
-  
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The adjustment that holds the value of the spinbutton.
-   *
-   * 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::Adjustment*> property_adjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The adjustment that holds the value of the spinbutton.
-   *
-   * 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::Adjustment*> property_adjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The acceleration rate when you hold down a button.
-   *
-   * 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_climb_rate() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The acceleration rate when you hold down a button.
-   *
-   * 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_climb_rate() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of decimal places to display.
-   *
-   * 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_digits() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of decimal places to display.
-   *
-   * 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_digits() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  virtual Glib::PropertyProxy_Base _property_renderable(); //override
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::CellRendererSpin
-   * @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.
-   */
-  Gtk::CellRendererSpin* wrap(GtkCellRendererSpin* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_CELLRENDERERSPIN_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc
index 26cc8533f9..3ffd88a287 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/cellrenderertext.h>
 #include <gtkmm/private/cellrenderertext_p.h>
 
@@ -30,17 +29,10 @@
 namespace Gtk
 {
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_Base CellRendererText::_property_renderable()
 {
   return property_text();
 }
-#else
-Glib::ustring CellRendererText::_property_renderable()
-{
-  return "text";
-}
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 void CellRendererText::edited(const Glib::ustring& path, const Glib::ustring& new_text)
 {
@@ -53,8 +45,7 @@ void CellRendererText::edited(const Glib::ustring& path, const Glib::ustring& ne
 namespace
 {
 
-
-static void CellRendererText_signal_edited_callback(GtkCellRendererText* self, const gchar* p0,const gchar* p1,void* data)
+void CellRendererText_signal_edited_callback(GtkCellRendererText* self, const gchar* p0,const gchar* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::ustring&,const Glib::ustring& > SlotType;
@@ -62,32 +53,27 @@ static void CellRendererText_signal_edited_callback(GtkCellRendererText* self, c
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 , Glib::convert_const_gchar_ptr_to_ustring(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo CellRendererText_signal_edited_info =
+const Glib::SignalProxyInfo CellRendererText_signal_edited_info =
 {
   "edited",
   (GCallback) &CellRendererText_signal_edited_callback,
   (GCallback) &CellRendererText_signal_edited_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -132,18 +118,10 @@ void CellRendererText_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->edited = &edited_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void CellRendererText_Class::edited_callback(GtkCellRendererText* self, const gchar* p0, const gchar* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -156,21 +134,17 @@ void CellRendererText_Class::edited_callback(GtkCellRendererText* self, const gc
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_edited(Glib::convert_const_gchar_ptr_to_ustring(p0)
 , Glib::convert_const_gchar_ptr_to_ustring(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -183,7 +157,6 @@ void CellRendererText_Class::edited_callback(GtkCellRendererText* self, const gc
       (*base->edited)(self, p0, p1);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* CellRendererText_Class::wrap_new(GObject* o)
@@ -234,7 +207,7 @@ CellRendererText::CellRendererText()
 
 void CellRendererText::set_fixed_height_from_font(int number_of_rows)
 {
-gtk_cell_renderer_text_set_fixed_height_from_font(gobj(), number_of_rows); 
+  gtk_cell_renderer_text_set_fixed_height_from_font(gobj(), number_of_rows);
 }
 
 
@@ -244,589 +217,397 @@ Glib::SignalProxy2< void,const Glib::ustring&,const Glib::ustring& > CellRendere
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_text() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_text() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_markup() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "markup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_markup() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "markup");
+}
+
 Glib::PropertyProxy<Pango::AttrList> CellRendererText::property_attributes() 
 {
   return Glib::PropertyProxy<Pango::AttrList>(this, "attributes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::AttrList> CellRendererText::property_attributes() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::AttrList>(this, "attributes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_background() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "background");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_background() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "background");
+}
+
 Glib::PropertyProxy_WriteOnly<Glib::ustring> CellRendererText::property_foreground() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "foreground");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_foreground() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "foreground");
+}
+
 Glib::PropertyProxy<Gdk::Color> CellRendererText::property_background_gdk() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "background-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRendererText::property_background_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "background-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::Color> CellRendererText::property_foreground_gdk() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "foreground-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> CellRendererText::property_foreground_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "foreground-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_font() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_font() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::FontDescription> CellRendererText::property_font_desc() 
 {
   return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::FontDescription> CellRendererText::property_font_desc() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_family() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "family");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_family() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Style> CellRendererText::property_style() 
 {
   return Glib::PropertyProxy<Pango::Style>(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Style> CellRendererText::property_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Variant> CellRendererText::property_variant() 
 {
   return Glib::PropertyProxy<Pango::Variant>(this, "variant");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Variant> CellRendererText::property_variant() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> CellRendererText::property_weight() 
 {
   return Glib::PropertyProxy<int>(this, "weight");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_weight() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Stretch> CellRendererText::property_stretch() 
 {
   return Glib::PropertyProxy<Pango::Stretch>(this, "stretch");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Stretch> CellRendererText::property_stretch() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Stretch>(this, "stretch");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> CellRendererText::property_size() 
 {
   return Glib::PropertyProxy<int>(this, "size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_size() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> CellRendererText::property_size_points() 
 {
   return Glib::PropertyProxy<double>(this, "size-points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> CellRendererText::property_size_points() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> CellRendererText::property_scale() 
 {
   return Glib::PropertyProxy<double>(this, "scale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> CellRendererText::property_scale() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_editable() 
 {
   return Glib::PropertyProxy<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_editable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_strikethrough() 
 {
   return Glib::PropertyProxy<bool>(this, "strikethrough");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_strikethrough() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Underline> CellRendererText::property_underline() 
 {
   return Glib::PropertyProxy<Pango::Underline>(this, "underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Underline> CellRendererText::property_underline() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> CellRendererText::property_rise() 
 {
   return Glib::PropertyProxy<int>(this, "rise");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_rise() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> CellRendererText::property_language() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "language");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> CellRendererText::property_language() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "language");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Pango::EllipsizeMode> CellRendererText::property_ellipsize() 
-{
-  return Glib::PropertyProxy<Pango::EllipsizeMode>(this, "ellipsize");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode> CellRendererText::property_ellipsize() const
-{
-  return Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode>(this, "ellipsize");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> CellRendererText::property_width_chars() 
-{
-  return Glib::PropertyProxy<int>(this, "width-chars");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_width_chars() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Pango::WrapMode> CellRendererText::property_wrap_mode() 
-{
-  return Glib::PropertyProxy<Pango::WrapMode>(this, "wrap-mode");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Pango::WrapMode> CellRendererText::property_wrap_mode() const
+Glib::PropertyProxy<bool> CellRendererText::property_ellipsize() 
 {
-  return Glib::PropertyProxy_ReadOnly<Pango::WrapMode>(this, "wrap-mode");
+  return Glib::PropertyProxy<bool>(this, "ellipsize");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> CellRendererText::property_wrap_width() 
+Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_ellipsize() const
 {
-  return Glib::PropertyProxy<int>(this, "wrap-width");
+  return Glib::PropertyProxy_ReadOnly<bool>(this, "ellipsize");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> CellRendererText::property_wrap_width() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "wrap-width");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Pango::Alignment> CellRendererText::property_alignment() 
-{
-  return Glib::PropertyProxy<Pango::Alignment>(this, "alignment");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Pango::Alignment> CellRendererText::property_alignment() const
-{
-  return Glib::PropertyProxy_ReadOnly<Pango::Alignment>(this, "alignment");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_background_set() 
 {
   return Glib::PropertyProxy<bool>(this, "background-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_background_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_foreground_set() 
 {
   return Glib::PropertyProxy<bool>(this, "foreground-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_foreground_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_family_set() 
 {
   return Glib::PropertyProxy<bool>(this, "family-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_family_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_style_set() 
 {
   return Glib::PropertyProxy<bool>(this, "style-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_style_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_variant_set() 
 {
   return Glib::PropertyProxy<bool>(this, "variant-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_variant_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_weight_set() 
 {
   return Glib::PropertyProxy<bool>(this, "weight-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_weight_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_stretch_set() 
 {
   return Glib::PropertyProxy<bool>(this, "stretch-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_stretch_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_size_set() 
 {
   return Glib::PropertyProxy<bool>(this, "size-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_size_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_scale_set() 
 {
   return Glib::PropertyProxy<bool>(this, "scale-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_scale_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_editable_set() 
 {
   return Glib::PropertyProxy<bool>(this, "editable-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_editable_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_strikethrough_set() 
 {
   return Glib::PropertyProxy<bool>(this, "strikethrough-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_strikethrough_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_underline_set() 
 {
   return Glib::PropertyProxy<bool>(this, "underline-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_underline_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_rise_set() 
 {
   return Glib::PropertyProxy<bool>(this, "rise-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_rise_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_language_set() 
 {
   return Glib::PropertyProxy<bool>(this, "language-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_language_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "language-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_ellipsize_set() 
 {
   return Glib::PropertyProxy<bool>(this, "ellipsize-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_ellipsize_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "ellipsize-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererText::property_single_paragraph_mode() 
 {
   return Glib::PropertyProxy<bool>(this, "single-paragraph-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererText::property_single_paragraph_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "single-paragraph-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::CellRendererText::on_edited(const Glib::ustring& path, const Glib::ustring& new_text)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -836,10 +617,6 @@ void Gtk::CellRendererText::on_edited(const Glib::ustring& path, const Glib::ust
   if(base && base->edited)
     (*base->edited)(gobj(),path.c_str(),new_text.c_str());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertext.h b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.h
index 408a9e4774..9135cdf83a 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderertext.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertext.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLRENDERERTEXT_H
 #define _GTKMM_CELLRENDERERTEXT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -89,18 +88,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_edited(const Glib::ustring& path, const Glib::ustring& new_text);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -121,25 +114,17 @@ public:
   void set_fixed_height_from_font(int number_of_rows);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %edited(const Glib::ustring& path, const Glib::ustring& new_text)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::ustring&,const Glib::ustring& > signal_edited();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text to render.
+  /** Text to render.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text to render.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -147,30 +132,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Marked up text to render.
+  /** Marked up text to render.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
+/** Marked up text to render.
+   *
+   * 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;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A list of style attributes to apply to the text of the renderer.
+  /** A list of style attributes to apply to the text of the renderer.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A list of style attributes to apply to the text of the renderer.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -178,41 +164,47 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::AttrList> property_attributes() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Background color as a string.
+  /** Background color as a string.
    *
    * 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_background() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
+/** Background color as a string.
+   *
+   * 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_background() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Foreground color as a string.
+  /** Foreground color as a string.
    *
    * 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_foreground() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
+/** Foreground color as a string.
+   *
+   * 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_foreground() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Background color as a GdkColor.
+  /** Background color as a GdkColor.
    *
    * 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_background_gdk() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Background color as a GdkColor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -220,19 +212,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_background_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Foreground color as a GdkColor.
+  /** Foreground color as a GdkColor.
    *
    * 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_foreground_gdk() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Foreground color as a GdkColor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -240,19 +228,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_foreground_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a string.
+  /** Font description as a string.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font description as a string.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -260,19 +244,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a PangoFontDescription struct.
+  /** Font description as a PangoFontDescription struct.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font description as a PangoFontDescription struct.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -280,19 +260,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::FontDescription> property_font_desc() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of the font family
+  /** Name of the font 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<Glib::ustring> property_family() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Name of the font family
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -300,19 +276,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_family() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font style.
+  /** Font 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<Pango::Style> property_style() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font style.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -320,19 +292,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Style> property_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font variant.
+  /** Font 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<Pango::Variant> property_variant() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font variant.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -340,19 +308,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Variant> property_variant() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font weight.
+  /** Font 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<int> property_weight() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font weight.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -360,19 +324,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_weight() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font stretch.
+  /** Font 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<Pango::Stretch> property_stretch() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font stretch.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -380,19 +340,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Stretch> property_stretch() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font size.
+  /** Font 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<int> property_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font size.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -400,19 +356,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font size in points.
+  /** Font size in 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<double> property_size_points() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font size in points.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -420,19 +372,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_size_points() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font scaling factor.
+  /** Font scaling factor.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font scaling factor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -440,19 +388,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_scale() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the text can be modified by the user.
+  /** Whether the text can be modified by the user.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the text can be modified by the user.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -460,19 +404,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to strike through the text.
+  /** Whether to strike through the 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<bool> property_strikethrough() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to strike through the text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -480,19 +420,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_strikethrough() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Style of underline for this text.
+  /** Style of underline for this 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<Pango::Underline> property_underline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Style of underline for this text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -500,19 +436,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Underline> property_underline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Offset of text above the baseline (below the baseline if rise is negative).
+  /** Offset of text above the baseline (below the baseline if rise is negative).
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Offset of text above the baseline (below the baseline if rise is negative).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -520,19 +452,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_rise() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The language this text is in
+  /** The language this text is in
    *
    * 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_language() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The language this text is in
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -540,119 +468,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_language() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The preferred place to ellipsize the string
+  /** The preferred place to ellipsize the string
    *
    * 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::EllipsizeMode> property_ellipsize() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy<bool> property_ellipsize() ;
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The preferred place to ellipsize the string
    *
    * 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::EllipsizeMode> property_ellipsize() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The desired width of the label
-   *
-   * 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_width_chars() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy_ReadOnly<bool> property_ellipsize() const;
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The desired width of the label
-   *
-   * 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_width_chars() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** How to break the string into multiple 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<Pango::WrapMode> property_wrap_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** How to break the string into multiple 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<Pango::WrapMode> property_wrap_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The width at which the text is wrapped.
-   *
-   * 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_wrap_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The width at which the text is wrapped.
-   *
-   * 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_wrap_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** How to align the 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<Pango::Alignment> property_alignment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** How to align the 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<Pango::Alignment> property_alignment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the background color.
+  /** Whether this tag affects the background 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<bool> property_background_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the background color.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -660,19 +500,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_background_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the foreground color.
+  /** Whether this tag affects the foreground 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<bool> property_foreground_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the foreground color.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -680,19 +516,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_foreground_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font family.
+  /** Whether this tag affects the font 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<bool> property_family_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font family.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -700,19 +532,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_family_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font style.
+  /** Whether this tag affects the font 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<bool> property_style_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font style.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -720,19 +548,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_style_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font variant.
+  /** Whether this tag affects the font 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<bool> property_variant_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font variant.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -740,19 +564,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_variant_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font weight.
+  /** Whether this tag affects the font 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<bool> property_weight_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font weight.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -760,19 +580,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_weight_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font stretch.
+  /** Whether this tag affects the font 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<bool> property_stretch_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font stretch.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -780,19 +596,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_stretch_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font size.
+  /** Whether this tag affects the font 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<bool> property_size_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font size.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -800,19 +612,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_size_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag scales the font size by a factor.
+  /** Whether this tag scales the font size by a factor.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag scales the font size by a factor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -820,19 +628,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_scale_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects text editability.
+  /** Whether this tag affects text editability.
    *
    * 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_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects text editability.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -840,19 +644,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_editable_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects strikethrough.
+  /** Whether this tag affects 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<bool> property_strikethrough_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects strikethrough.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -860,19 +660,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_strikethrough_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects underlining.
+  /** Whether this tag affects underlining.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects underlining.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -880,19 +676,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_underline_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the rise.
+  /** Whether this tag affects the 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<bool> property_rise_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the rise.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -900,19 +692,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_rise_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the language the text is rendered as.
+  /** Whether this tag affects the language the text is rendered as.
    *
    * 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_language_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the language the text is rendered as.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -920,19 +708,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_language_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the ellipsize mode.
+  /** Whether this tag affects the ellipsize 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<bool> property_ellipsize_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the ellipsize mode.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -940,19 +724,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_ellipsize_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether or not to keep all text in a single paragraph.
+  /** Whether or not to keep all text in a single paragraph.
    *
    * 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_single_paragraph_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether or not to keep all text in a single paragraph.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -960,14 +740,9 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_single_paragraph_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  virtual Glib::PropertyProxy_Base _property_renderable();
-#else
-  virtual Glib::ustring _property_renderable();
-#endif
+  
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
 
 protected:
   /** Emits the "edited" signal.
@@ -989,8 +764,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CellRendererText* wrap(GtkCellRendererText* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CELLRENDERERTEXT_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.cc b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.cc
index 55742abf81..023c5382dd 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/cellrenderertoggle.h>
 #include <gtkmm/private/cellrenderertoggle_p.h>
 
@@ -31,25 +30,18 @@
 namespace Gtk
 {
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_Base CellRendererToggle::_property_renderable()
 {
   return property_active();
 }
-#else
-Glib::ustring CellRendererToggle::_property_renderable()
-{
-  return "active";
-}
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 } //namespace Gtk
 
+
 namespace
 {
 
-
-static void CellRendererToggle_signal_toggled_callback(GtkCellRendererToggle* self, const gchar* p0,void* data)
+void CellRendererToggle_signal_toggled_callback(GtkCellRendererToggle* self, const gchar* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::ustring& > SlotType;
@@ -57,31 +49,26 @@ static void CellRendererToggle_signal_toggled_callback(GtkCellRendererToggle* se
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo CellRendererToggle_signal_toggled_info =
+const Glib::SignalProxyInfo CellRendererToggle_signal_toggled_info =
 {
   "toggled",
   (GCallback) &CellRendererToggle_signal_toggled_callback,
   (GCallback) &CellRendererToggle_signal_toggled_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -126,18 +113,10 @@ void CellRendererToggle_Class::class_init_function(void* g_class, void* class_da
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->toggled = &toggled_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void CellRendererToggle_Class::toggled_callback(GtkCellRendererToggle* self, const gchar* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -150,20 +129,16 @@ void CellRendererToggle_Class::toggled_callback(GtkCellRendererToggle* self, con
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggled(Glib::convert_const_gchar_ptr_to_ustring(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -176,7 +151,6 @@ void CellRendererToggle_Class::toggled_callback(GtkCellRendererToggle* self, con
       (*base->toggled)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* CellRendererToggle_Class::wrap_new(GObject* o)
@@ -232,7 +206,7 @@ bool CellRendererToggle::get_radio() const
 
 void CellRendererToggle::set_radio(bool radio)
 {
-gtk_cell_renderer_toggle_set_radio(gobj(), static_cast<int>(radio)); 
+  gtk_cell_renderer_toggle_set_radio(gobj(), static_cast<int>(radio));
 }
 
 bool CellRendererToggle::get_active() const
@@ -242,7 +216,7 @@ bool CellRendererToggle::get_active() const
 
 void CellRendererToggle::set_active(bool setting)
 {
-gtk_cell_renderer_toggle_set_active(gobj(), static_cast<int>(setting)); 
+  gtk_cell_renderer_toggle_set_active(gobj(), static_cast<int>(setting));
 }
 
 
@@ -252,64 +226,37 @@ Glib::SignalProxy1< void,const Glib::ustring& > CellRendererToggle::signal_toggl
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererToggle::property_activatable() 
 {
   return Glib::PropertyProxy<bool>(this, "activatable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_activatable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "activatable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererToggle::property_active() 
 {
   return Glib::PropertyProxy<bool>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_active() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CellRendererToggle::property_radio() 
 {
   return Glib::PropertyProxy<bool>(this, "radio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CellRendererToggle::property_radio() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "radio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> CellRendererToggle::property_indicator_size() 
-{
-  return Glib::PropertyProxy<int>(this, "indicator-size");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> CellRendererToggle::property_indicator_size() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "indicator-size");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::CellRendererToggle::on_toggled(const Glib::ustring& path)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -319,10 +266,6 @@ void Gtk::CellRendererToggle::on_toggled(const Glib::ustring& path)
   if(base && base->toggled)
     (*base->toggled)(gobj(),path.c_str());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.h b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.h
index 56f0d9df4f..293f4e7750 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellrenderertoggle.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLRENDERERTOGGLE_H
 #define _GTKMM_CELLRENDERERTOGGLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -91,18 +90,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_toggled(const Glib::ustring& path);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -112,7 +105,7 @@ public:
   CellRendererToggle();
   
 
-  /** Returns whether we're rendering radio toggles rather than checkboxes.
+  /** Returns wether we're rendering radio toggles rather than checkboxes.
    * @return <tt>true</tt> if we're rendering radio toggles rather than checkboxes.
    */
   bool get_radio() const;
@@ -139,31 +132,18 @@ public:
    */
   void set_active(bool setting = true);
 
-   //TODO: Maybe the parameter should be a TreePath.
-  /** The toggled signal is emitted when the cell is toggled.
-   *
-   * @param path string representation of TreePath describing the event location
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %toggled(const Glib::ustring& path)</tt>
-   */
 
   Glib::SignalProxy1< void,const Glib::ustring& > signal_toggled();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The toggle button can be activated.
+  /** The toggle button can be activated.
    *
    * 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_activatable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The toggle button can be activated.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -171,19 +151,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_activatable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The toggle state of the button.
+  /** The toggle state of the button.
    *
    * 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_active() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The toggle state of the button.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -191,19 +167,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_active() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Draw the toggle button as a radio button.
+  /** Draw the toggle button as a radio button.
    *
    * 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_radio() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Draw the toggle button as a radio button.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -211,34 +183,9 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_radio() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Size of check or radio indicator.
-   *
-   * 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_indicator_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Size of check or radio indicator.
-   *
-   * 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_indicator_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-  virtual Glib::PropertyProxy_Base _property_renderable();
-#else
-  virtual Glib::ustring _property_renderable();
-#endif
+  virtual Glib::PropertyProxy_Base _property_renderable(); //override
 
 
 };
@@ -254,8 +201,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CellRendererToggle* wrap(GtkCellRendererToggle* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CELLRENDERERTOGGLE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellview.cc b/libs/gtkmm2/gtk/gtkmm/cellview.cc
index 3691fbaa6b..5b57ccf3a0 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellview.cc
+++ b/libs/gtkmm2/gtk/gtkmm/cellview.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/cellview.h>
 #include <gtkmm/private/cellview_p.h>
 
@@ -39,24 +38,12 @@ CellView::CellView(const Glib::ustring& text, bool use_markup)
   Gtk::Widget(Glib::ConstructParams(cellview_class_.init(), (char*) 0))
 {
   Gtk::CellRendererText* cell = Gtk::manage(new Gtk::CellRendererText());
-
+  
   if(use_markup)
-  {
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     cell->property_markup() = text;
-    #else
-    cell->set_property("markup", text);
-    #endif
-  }
   else
-  {
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     cell->property_text() = text;
-    #else
-    cell->set_property("text", text);
-    #endif
-  }
-
+  
   pack_start(*cell);
 }
 
@@ -66,19 +53,15 @@ CellView::CellView(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
   Gtk::Widget(Glib::ConstructParams(cellview_class_.init(), (char*) 0))
 {
   Gtk::CellRendererPixbuf* cell = Gtk::manage(new Gtk::CellRendererPixbuf());
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
   cell->property_pixbuf() = pixbuf;
-  #else
-  cell->set_property("pixbuf", (void*)(pixbuf->gobj()));
-  #endif
-
+  
   pack_start(*cell);
 }
 
 
 } //namespace Gtk
 
+
 namespace
 {
 } // anonymous namespace
@@ -126,19 +109,8 @@ void CellView_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* CellView_Class::wrap_new(GObject* o)
 {
@@ -188,12 +160,12 @@ CellView::CellView()
 
 void CellView::set_model(const Glib::RefPtr<TreeModel>& model)
 {
-gtk_cell_view_set_model(gobj(), Glib::unwrap(model)); 
+  gtk_cell_view_set_model(gobj(), Glib::unwrap(model));
 }
 
 void CellView::set_displayed_row(const TreeModel::Path& path)
 {
-gtk_cell_view_set_displayed_row(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
+  gtk_cell_view_set_displayed_row(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 TreeModel::Path CellView::get_displayed_row() const
@@ -208,7 +180,7 @@ bool CellView::get_size_of_row(const TreeModel::Path& path, Requisition& requisi
 
 void CellView::set_background_color(const Gdk::Color& color)
 {
-gtk_cell_view_set_background_color(gobj(), (color).gobj()); 
+  gtk_cell_view_set_background_color(gobj(), (color).gobj());
 }
 
 Glib::ListHandle<CellRenderer*> CellView::get_cell_renderers()
@@ -222,13 +194,6 @@ Glib::ListHandle<const CellRenderer*> CellView::get_cell_renderers() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/cellview.h b/libs/gtkmm2/gtk/gtkmm/cellview.h
index a804824739..6e798c5f56 100644
--- a/libs/gtkmm2/gtk/gtkmm/cellview.h
+++ b/libs/gtkmm2/gtk/gtkmm/cellview.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CELLVIEW_H
 #define _GTKMM_CELLVIEW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -99,17 +98,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -142,7 +135,7 @@ public:
    * set, it will remove it before setting the new model.  If @a model  is 
    * <tt>0</tt>, then it will unset the old model.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param model A Gtk::TreeModel.
    */
   void set_model(const Glib::RefPtr<TreeModel>& model);
@@ -154,18 +147,11 @@ public:
    * a needed intermediate state if say, the model for
    * the Gtk::CellView becomes temporarily empty.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param path A Gtk::TreePath or <tt>0</tt> to unset.
    */
   void set_displayed_row(const TreeModel::Path& path);
   
-  /** Returns a Gtk::TreePath referring to the currently 
-   * displayed row. If no row is currently displayed, 
-   * <tt>0</tt> is returned.
-   * @return The currently displayed row or <tt>0</tt>
-   * 
-   * @newin2p6.
-   */
   TreeModel::Path get_displayed_row() const;
   
   /** Sets @a requisition  to the size needed by @a cell_view  to display 
@@ -174,14 +160,14 @@ public:
    * @param requisition Return location for the size.
    * @return <tt>true</tt>
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_size_of_row(const TreeModel::Path& path, Requisition& requisition) const;
 
   
   /** Sets the background color of @a view .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param color The new background color.
    */
   void set_background_color(const Gdk::Color& color);
@@ -192,7 +178,7 @@ public:
    * renderers has been newly allocated and should be freed with
    * Glib::list_free() when no longer needed.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ListHandle<CellRenderer*> get_cell_renderers();
   
@@ -201,7 +187,7 @@ public:
    * renderers has been newly allocated and should be freed with
    * Glib::list_free() when no longer needed.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ListHandle<const CellRenderer*> get_cell_renderers() const;
 
@@ -219,8 +205,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CellView* wrap(GtkCellView* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CELLVIEW_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/checkbutton.cc b/libs/gtkmm2/gtk/gtkmm/checkbutton.cc
index 61fec35704..110d0c5edc 100644
--- a/libs/gtkmm2/gtk/gtkmm/checkbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/checkbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/checkbutton.h>
 #include <gtkmm/private/checkbutton_p.h>
 
@@ -86,15 +85,9 @@ void CheckButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->draw_indicator = &draw_indicator_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void CheckButton_Class::draw_indicator_vfunc_callback(GtkCheckButton* self, GdkRectangle* area)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -107,19 +100,15 @@ void CheckButton_Class::draw_indicator_vfunc_callback(GtkCheckButton* self, GdkR
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_indicator_vfunc(area);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -132,10 +121,6 @@ void CheckButton_Class::draw_indicator_vfunc_callback(GtkCheckButton* self, GdkR
       (*base->draw_indicator)(self, area);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* CheckButton_Class::wrap_new(GObject* o)
@@ -185,10 +170,6 @@ CheckButton::CheckButton()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Gtk::CheckButton::draw_indicator_vfunc(GdkRectangle* area) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -198,7 +179,6 @@ void Gtk::CheckButton::draw_indicator_vfunc(GdkRectangle* area)
   if(base && base->draw_indicator)
     (*base->draw_indicator)(gobj(),area);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/checkbutton.h b/libs/gtkmm2/gtk/gtkmm/checkbutton.h
index 2e33cf9f6d..bff262d400 100644
--- a/libs/gtkmm2/gtk/gtkmm/checkbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/checkbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CHECKBUTTON_H
 #define _GTKMM_CHECKBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -94,17 +93,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -136,11 +129,9 @@ protected:
    * The GdkRectangle specifies the area of the widget which will get
    * redrawn.
    */
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_indicator_vfunc(GdkRectangle* area);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void draw_indicator_vfunc(GdkRectangle* area);
   
+
 };
 
 
@@ -155,8 +146,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CheckButton* wrap(GtkCheckButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CHECKBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/checkmenuitem.cc b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.cc
index f66910811f..2a1a6b4ac2 100644
--- a/libs/gtkmm2/gtk/gtkmm/checkmenuitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/checkmenuitem.h>
 #include <gtkmm/private/checkmenuitem_p.h>
 
@@ -47,15 +46,13 @@ CheckMenuItem::CheckMenuItem(const Glib::ustring& label, bool mnemonic)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo CheckMenuItem_signal_toggled_info =
+const Glib::SignalProxyInfo CheckMenuItem_signal_toggled_info =
 {
   "toggled",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -100,16 +97,10 @@ void CheckMenuItem_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->draw_indicator = &draw_indicator_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->toggled = &toggled_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void CheckMenuItem_Class::draw_indicator_vfunc_callback(GtkCheckMenuItem* self, GdkRectangle* area)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -122,19 +113,15 @@ void CheckMenuItem_Class::draw_indicator_vfunc_callback(GtkCheckMenuItem* self,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_indicator_vfunc(area);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -147,9 +134,8 @@ void CheckMenuItem_Class::draw_indicator_vfunc_callback(GtkCheckMenuItem* self,
       (*base->draw_indicator)(self, area);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void CheckMenuItem_Class::toggled_callback(GtkCheckMenuItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -162,19 +148,15 @@ void CheckMenuItem_Class::toggled_callback(GtkCheckMenuItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggled();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -187,7 +169,6 @@ void CheckMenuItem_Class::toggled_callback(GtkCheckMenuItem* self)
       (*base->toggled)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* CheckMenuItem_Class::wrap_new(GObject* o)
@@ -238,7 +219,7 @@ CheckMenuItem::CheckMenuItem()
 
 void CheckMenuItem::set_active(bool state)
 {
-gtk_check_menu_item_set_active(gobj(), static_cast<int>(state)); 
+  gtk_check_menu_item_set_active(gobj(), static_cast<int>(state));
 }
 
 bool CheckMenuItem::get_active() const
@@ -248,12 +229,12 @@ bool CheckMenuItem::get_active() const
 
 void CheckMenuItem::toggled()
 {
-gtk_check_menu_item_toggled(gobj()); 
+  gtk_check_menu_item_toggled(gobj());
 }
 
 void CheckMenuItem::set_inconsistent(bool setting)
 {
-gtk_check_menu_item_set_inconsistent(gobj(), static_cast<int>(setting)); 
+  gtk_check_menu_item_set_inconsistent(gobj(), static_cast<int>(setting));
 }
 
 bool CheckMenuItem::get_inconsistent() const
@@ -263,7 +244,7 @@ bool CheckMenuItem::get_inconsistent() const
 
 void CheckMenuItem::set_draw_as_radio(bool draw_as_radio)
 {
-gtk_check_menu_item_set_draw_as_radio(gobj(), static_cast<int>(draw_as_radio)); 
+  gtk_check_menu_item_set_draw_as_radio(gobj(), static_cast<int>(draw_as_radio));
 }
 
 bool CheckMenuItem::get_draw_as_radio() const
@@ -278,50 +259,37 @@ Glib::SignalProxy0< void > CheckMenuItem::signal_toggled()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CheckMenuItem::property_active() 
 {
   return Glib::PropertyProxy<bool>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CheckMenuItem::property_active() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CheckMenuItem::property_inconsistent() 
 {
   return Glib::PropertyProxy<bool>(this, "inconsistent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CheckMenuItem::property_inconsistent() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "inconsistent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> CheckMenuItem::property_draw_as_radio() 
 {
   return Glib::PropertyProxy<bool>(this, "draw-as-radio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> CheckMenuItem::property_draw_as_radio() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-as-radio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::CheckMenuItem::on_toggled()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -331,9 +299,8 @@ void Gtk::CheckMenuItem::on_toggled()
   if(base && base->toggled)
     (*base->toggled)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::CheckMenuItem::draw_indicator_vfunc(GdkRectangle* area) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -343,7 +310,6 @@ void Gtk::CheckMenuItem::draw_indicator_vfunc(GdkRectangle* area)
   if(base && base->draw_indicator)
     (*base->draw_indicator)(gobj(),area);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/checkmenuitem.h b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.h
index 0aa9405b5b..faa95d431f 100644
--- a/libs/gtkmm2/gtk/gtkmm/checkmenuitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/checkmenuitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CHECKMENUITEM_H
 #define _GTKMM_CHECKMENUITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -91,18 +90,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_toggled();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -146,7 +139,7 @@ public:
   
   /** Sets whether @a check_menu_item  is drawn like a Gtk::RadioMenuItem
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param draw_as_radio Whether @a check_menu_item  is drawn like a Gtk::RadioMenuItem.
    */
   void set_draw_as_radio(bool draw_as_radio = true);
@@ -154,7 +147,7 @@ public:
   /** Returns whether @a check_menu_item  looks like a Gtk::RadioMenuItem
    * @return Whether @a check_menu_item  looks like a Gtk::RadioMenuItem
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_draw_as_radio() const;
   
@@ -163,25 +156,18 @@ public:
    * this signal)
    */
   
-/**
-   * @par Prototype:
-   * <tt>void %toggled()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_toggled();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the menu item is checked.
+  /** Whether the menu item is checked.
    *
    * 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_active() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the menu item is checked.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -189,19 +175,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_active() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to display an inconsistent state.
+  /** Whether to display an inconsistent state.
    *
    * 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_inconsistent() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to display an inconsistent state.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -209,19 +191,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_inconsistent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the menu item looks like a radio menu item.
+  /** Whether the menu item looks like a radio menu item.
    *
    * 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_draw_as_radio() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the menu item looks like a radio menu item.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -229,7 +207,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_draw_as_radio() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -239,9 +216,7 @@ protected:
    * The GdkRectangle specifies the area of the widget which will get
    * redrawn.
    */
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_indicator_vfunc(GdkRectangle* area);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void draw_indicator_vfunc(GdkRectangle* area);
 
 
 };
@@ -257,8 +232,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::CheckMenuItem* wrap(GtkCheckMenuItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CHECKMENUITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/clipboard.cc b/libs/gtkmm2/gtk/gtkmm/clipboard.cc
index 341e015130..e543bb8eee 100644
--- a/libs/gtkmm2/gtk/gtkmm/clipboard.cc
+++ b/libs/gtkmm2/gtk/gtkmm/clipboard.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/clipboard.h>
 #include <gtkmm/private/clipboard_p.h>
 
@@ -26,7 +25,6 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <gtkmm/textbuffer.h>
 #include <gtkmm/selectiondata_private.h>
 #include <glibmm/utility.h> //For ScopedPtr<>.
 #include <gtk/gtkclipboard.h>
@@ -41,11 +39,13 @@ class SignalProxy_GetClear
 public:
   SignalProxy_GetClear(const Gtk::Clipboard::SlotGet& slot_get,
                        const Gtk::Clipboard::SlotClear& slot_clear);
+  ~SignalProxy_GetClear();
 
   static void gtk_callback_get(GtkClipboard* clipboard, GtkSelectionData* selection_data,
                                unsigned int info, void* data);
   static void gtk_callback_clear(GtkClipboard* clipboard, void* data);
 
+protected:
   Gtk::Clipboard::SlotGet   slot_get_;
   Gtk::Clipboard::SlotClear slot_clear_;
 };
@@ -57,42 +57,37 @@ SignalProxy_GetClear::SignalProxy_GetClear(const Gtk::Clipboard::SlotGet& slot_g
   slot_clear_ (slot_clear)
 {}
 
-static void SignalProxy_GetClear_gtk_callback_get(GtkClipboard*, GtkSelectionData* selection_data,
+SignalProxy_GetClear::~SignalProxy_GetClear()
+{}
+
+void SignalProxy_GetClear::gtk_callback_get(GtkClipboard*, GtkSelectionData* selection_data,
                                             unsigned int info, void* data)
 {
   SignalProxy_GetClear *const self = static_cast<SignalProxy_GetClear*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Gtk::SelectionData_WithoutOwnership cppSelectionData(selection_data);
     (self->slot_get_)(cppSelectionData, info);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void SignalProxy_GetClear_gtk_callback_clear(GtkClipboard*, void* data)
+void SignalProxy_GetClear::gtk_callback_clear(GtkClipboard*, void* data)
 {
   SignalProxy_GetClear *const self = static_cast<SignalProxy_GetClear*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     (self->slot_clear_)();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   delete self; // After this callback has been called, none of the 2 callbacks will be called again.
 
@@ -100,30 +95,73 @@ static void SignalProxy_GetClear_gtk_callback_clear(GtkClipboard*, void* data)
   //because clear() is called when set() is called again.
 }
 
-} //anonymous namespace
 
+// SignalProxy_Received:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Received
+{
+public:
+  typedef Gtk::Clipboard::SlotReceived SlotType;
+
+  SignalProxy_Received(const SlotType& slot);
+  ~SignalProxy_Received();
+
+  static void gtk_callback(GtkClipboard* clipboard, GtkSelectionData* selection_data, gpointer data);
 
-static void SignalProxy_Received_gtk_callback(GtkClipboard*, GtkSelectionData* selection_data, void* data)
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_Received::SignalProxy_Received(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Received::~SignalProxy_Received()
+{}
+
+void SignalProxy_Received::gtk_callback(GtkClipboard*, GtkSelectionData* selection_data, void* data)
 {
-  Gtk::Clipboard::SlotReceived* the_slot = static_cast<Gtk::Clipboard::SlotReceived*>(data);
+  SignalProxy_Received *const self = static_cast<SignalProxy_Received*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Gtk::SelectionData cppSelectionData(selection_data, true /*take_copy=true*/);
-    (*the_slot)(cppSelectionData);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)(cppSelectionData);
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
-  delete the_slot;
+  delete self;
 }
 
+
+// SignalProxy_TargetsReceived:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_TargetsReceived
+{
+public:
+  typedef Gtk::Clipboard::SlotTargetsReceived SlotType;
+
+  SignalProxy_TargetsReceived(const SlotType& slot);
+  ~SignalProxy_TargetsReceived();
+
+  static void gtk_callback(GtkClipboard* clipboard, GdkAtom* atoms, gint n_atoms, gpointer data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_TargetsReceived::SignalProxy_TargetsReceived(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_TargetsReceived::~SignalProxy_TargetsReceived()
+{}
+
 //This is not public API:
 typedef std::list<Glib::ustring> listStrings;
 static listStrings util_convert_atoms_to_strings(GdkAtom* targets, int n_targets)
@@ -134,102 +172,115 @@ static listStrings util_convert_atoms_to_strings(GdkAtom* targets, int n_targets
   for(int i = 0; i < n_targets; i++)
   {
     //Convert the atom to a string:
-    char* atom_name = gdk_atom_name(targets[i]);
-    if(atom_name)
-    {
-      listTargets.push_back( Glib::ustring(atom_name) );
-      g_free(atom_name);
-    }
+    Glib::ustring target = gdk_atom_name(targets[i]);
+    listTargets.push_back(target);
   }
 
   return listTargets;
 }
 
-static void SignalProxy_TargetsReceived_gtk_callback(GtkClipboard*, GdkAtom* atoms, gint n_atoms, gpointer data)
+void SignalProxy_TargetsReceived::gtk_callback(GtkClipboard*, GdkAtom* atoms, gint n_atoms, gpointer data)
 {
-  Gtk::Clipboard::SlotTargetsReceived* the_slot = static_cast<Gtk::Clipboard::SlotTargetsReceived*>(data);
+  SignalProxy_TargetsReceived *const self = static_cast<SignalProxy_TargetsReceived*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     listStrings listTargets = util_convert_atoms_to_strings(atoms, n_atoms);
-    (*the_slot)(listTargets);
+    (self->slot_)(listTargets);
     //I guess that GTK+ does a g_free of the GdkAtoms* array itself, so we do not need to. murrayc.
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
-  delete the_slot; // the callback is only used once
+  delete self; // the callback is only used once
 }
 
 
-static void SignalProxy_TextReceived_gtk_callback(GtkClipboard*, const char* text, void* data)
+// SignalProxy_TextReceived:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_TextReceived
 {
-  Gtk::Clipboard::SlotTextReceived* the_slot = static_cast<Gtk::Clipboard::SlotTextReceived*>(data);
+public:
+  typedef Gtk::Clipboard::SlotTextReceived SlotType;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    (*the_slot)((text) ? Glib::ustring(text) : Glib::ustring());
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  SignalProxy_TextReceived(const SlotType& slot);
+  ~SignalProxy_TextReceived();
 
-  delete the_slot; // the callback is only used once
-}
+  static void gtk_callback(GtkClipboard* clipboard, const char* text, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_TextReceived::SignalProxy_TextReceived(const SlotType& slot)
+:
+  slot_ (slot)
+{}
 
-static void SignalProxy_RichTextReceived_gtk_callback(GtkClipboard*, GdkAtom format, const guint8* text, gsize             length, void* data)
+SignalProxy_TextReceived::~SignalProxy_TextReceived()
+{}
+
+void SignalProxy_TextReceived::gtk_callback(GtkClipboard*, const char* text, void* data)
 {
-  Gtk::Clipboard::SlotRichTextReceived* the_slot = static_cast<Gtk::Clipboard::SlotRichTextReceived*>(data);
+  SignalProxy_TextReceived *const self = static_cast<SignalProxy_TextReceived*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    gchar* format_atom_name = gdk_atom_name(format);
-    (*the_slot)( (format_atom_name ? Glib::ustring(format_atom_name) : Glib::ustring()), (text ? std::string((char*)text, length) : std::string()) );
-    g_free(format_atom_name);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)((text) ? Glib::ustring(text) : Glib::ustring());
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
-  delete the_slot; // the callback is only used once
+  delete self; // the callback is only used once
 }
 
-static void SignalProxy_ImageReceived_gtk_callback(GtkClipboard*, GdkPixbuf* image, void* data)
+
+// SignalProxy_ImageReceived:
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_ImageReceived
+{
+public:
+  typedef Gtk::Clipboard::SlotImageReceived SlotType;
+
+  SignalProxy_ImageReceived(const SlotType& slot);
+  ~SignalProxy_ImageReceived();
+
+  static void gtk_callback(GtkClipboard* clipboard, GdkPixbuf* image, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_ImageReceived::SignalProxy_ImageReceived(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_ImageReceived::~SignalProxy_ImageReceived()
+{}
+
+void SignalProxy_ImageReceived::gtk_callback(GtkClipboard*, GdkPixbuf* image, void* data)
 {
-  Gtk::Clipboard::SlotImageReceived* the_slot = static_cast<Gtk::Clipboard::SlotImageReceived*>(data);
+  SignalProxy_ImageReceived *const self = static_cast<SignalProxy_ImageReceived*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    (*the_slot)(Glib::wrap(image, true /* take_ref */));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)(Glib::wrap(image, true /* take_ref */));
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
-  delete the_slot; // the callback is only used once
+  delete self; // the callback is only used once
 }
 
+} // anonymous namespace
+
 
 namespace Gtk
 {
@@ -242,8 +293,8 @@ bool Clipboard::set(const ArrayHandle_TargetEntry& targets,
 
   return gtk_clipboard_set_with_data(
       gobj(), targets.data(), targets.size(),
-      &SignalProxy_GetClear_gtk_callback_get,
-      &SignalProxy_GetClear_gtk_callback_clear,
+      &SignalProxy_GetClear::gtk_callback_get,
+      &SignalProxy_GetClear::gtk_callback_clear,
       pSignalProxy);
 }
 
@@ -255,46 +306,37 @@ void Clipboard::set_text(const Glib::ustring& text)
 
 void Clipboard::request_contents(const Glib::ustring& target, const SlotReceived& slot)
 {
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  SlotReceived* slot_copy = new SlotReceived(slot);
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_Received *const pSignalProxy = new SignalProxy_Received(slot);
 
   gtk_clipboard_request_contents(gobj(), gdk_atom_intern(target.c_str(), FALSE),
-      &SignalProxy_Received_gtk_callback, slot_copy);
+      &SignalProxy_Received::gtk_callback, pSignalProxy);
 }
 
 void Clipboard::request_text(const SlotTextReceived& slot)
 {
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  SlotTextReceived* slot_copy = new SlotTextReceived(slot);
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_TextReceived *const pSignalProxy = new SignalProxy_TextReceived(slot);
 
   gtk_clipboard_request_text(gobj(),
-      &SignalProxy_TextReceived_gtk_callback, slot_copy);
-}
-
-void Clipboard::request_rich_text(const Glib::RefPtr<TextBuffer>& buffer, const SlotRichTextReceived& slot)
-{
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  SlotRichTextReceived* slot_copy = new SlotRichTextReceived(slot);
-
-  gtk_clipboard_request_rich_text(gobj(), buffer->gobj(), 
-      &SignalProxy_RichTextReceived_gtk_callback, slot_copy);
+      &SignalProxy_TextReceived::gtk_callback, pSignalProxy);
 }
 
 void Clipboard::request_image(const SlotImageReceived& slot)
 {
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  SlotImageReceived* slot_copy = new SlotImageReceived(slot);
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_ImageReceived *const pSignalProxy = new SignalProxy_ImageReceived(slot);
 
   gtk_clipboard_request_image(gobj(),
-      &SignalProxy_ImageReceived_gtk_callback, slot_copy);
+      &SignalProxy_ImageReceived::gtk_callback, pSignalProxy);
 }
 
 void Clipboard::request_targets(const SlotTargetsReceived& slot)
 {
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  SlotTargetsReceived* slot_copy = new SlotTargetsReceived(slot);
+  // Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  SignalProxy_TargetsReceived *const pSignalProxy = new SignalProxy_TargetsReceived(slot);
 
-  gtk_clipboard_request_targets(gobj(), &SignalProxy_TargetsReceived_gtk_callback, slot_copy);
+  gtk_clipboard_request_targets(gobj(), &SignalProxy_TargetsReceived::gtk_callback, pSignalProxy);
 }
 
 SelectionData Clipboard::wait_for_contents(const Glib::ustring& target) const
@@ -340,67 +382,12 @@ void Clipboard::set_can_store()
 {
   gtk_clipboard_set_can_store( gobj(), 0, 0 /* See C docs */ );
 }
-
-std::string Clipboard::wait_for_rich_text(const Glib::RefPtr<TextBuffer>& buffer, std::string& format)
-{
-  std::string result;
-
-  GdkAtom format_atom = 0;
-  gsize length = 0;
-  guint8* text = gtk_clipboard_wait_for_rich_text(const_cast<GtkClipboard*>(gobj()), buffer->gobj(), &format_atom, &length);
-  if(text && length)
-  {
-    gchar* format_atom_name = gdk_atom_name(format_atom);
-    if(format_atom_name)
-      format = Glib::ScopedPtr<char>(format_atom_name).get(); //This frees the buffer.
-
-    result = std::string((char*)text, length);
-    g_free(text);
-  }
-
-  return result;
-}
-
     
 } //namespace Gtk
 
 
 namespace
 {
-
-
-static void Clipboard_signal_owner_change_callback(GtkClipboard* self, GdkEventOwnerChange* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,GdkEventOwnerChange* > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo Clipboard_signal_owner_change_info =
-{
-  "owner_change",
-  (GCallback) &Clipboard_signal_owner_change_callback,
-  (GCallback) &Clipboard_signal_owner_change_callback
-};
-
-
 } // anonymous namespace
 
 
@@ -447,19 +434,8 @@ void Clipboard_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Clipboard_Class::wrap_new(GObject* object)
 {
@@ -512,7 +488,6 @@ Glib::RefPtr<Clipboard> Clipboard::get(GdkAtom selection)
   return retvalue;
 }
 
-
 Glib::RefPtr<Clipboard> Clipboard::get_for_display(const Glib::RefPtr<Gdk::Display>& display, GdkAtom selection)
 {
 
@@ -523,45 +498,54 @@ Glib::RefPtr<Clipboard> Clipboard::get_for_display(const Glib::RefPtr<Gdk::Displ
   return retvalue;
 }
 
-
 Glib::RefPtr<Gdk::Display> Clipboard::get_display()
 {
 
   Glib::RefPtr<Gdk::Display> retvalue = Glib::wrap(gtk_clipboard_get_display(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Display> Clipboard::get_display() const
 {
-  return const_cast<Clipboard*>(this)->get_display();
+
+  Glib::RefPtr<const Gdk::Display> retvalue = Glib::wrap(gtk_clipboard_get_display(const_cast<GtkClipboard*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Glib::Object> Clipboard::get_owner()
 {
 
   Glib::RefPtr<Glib::Object> retvalue = Glib::wrap(gtk_clipboard_get_owner(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Glib::Object> Clipboard::get_owner() const
 {
-  return const_cast<Clipboard*>(this)->get_owner();
+
+  Glib::RefPtr<const Glib::Object> retvalue = Glib::wrap(gtk_clipboard_get_owner(const_cast<GtkClipboard*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Clipboard::clear()
 {
-gtk_clipboard_clear(gobj()); 
+  gtk_clipboard_clear(gobj());
 }
 
 void Clipboard::set_image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
 {
-gtk_clipboard_set_image(gobj(), Glib::unwrap(pixbuf)); 
+  gtk_clipboard_set_image(gobj(), Glib::unwrap(pixbuf));
 }
 
 Glib::ustring Clipboard::wait_for_text() const
@@ -579,11 +563,6 @@ bool Clipboard::wait_is_text_available() const
   return gtk_clipboard_wait_is_text_available(const_cast<GtkClipboard*>(gobj()));
 }
 
-bool Clipboard::wait_is_rich_text_available(const Glib::RefPtr<TextBuffer>& buffer) const
-{
-  return gtk_clipboard_wait_is_rich_text_available(const_cast<GtkClipboard*>(gobj()), Glib::unwrap(buffer));
-}
-
 bool Clipboard::wait_is_image_available() const
 {
   return gtk_clipboard_wait_is_image_available(const_cast<GtkClipboard*>(gobj()));
@@ -596,23 +575,10 @@ bool Clipboard::wait_is_target_available(const Glib::ustring& target)
 
 void Clipboard::store()
 {
-gtk_clipboard_store(gobj()); 
+  gtk_clipboard_store(gobj());
 }
 
 
-Glib::SignalProxy1< void,GdkEventOwnerChange* > Clipboard::signal_owner_change()
-{
-  return Glib::SignalProxy1< void,GdkEventOwnerChange* >(this, &Clipboard_signal_owner_change_info);
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/clipboard.h b/libs/gtkmm2/gtk/gtkmm/clipboard.h
index 401a1738b9..193eae10cc 100644
--- a/libs/gtkmm2/gtk/gtkmm/clipboard.h
+++ b/libs/gtkmm2/gtk/gtkmm/clipboard.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CLIPBOARD_H
 #define _GTKMM_CLIPBOARD_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -46,10 +45,6 @@ namespace Gtk
 namespace Gtk
 {
 
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-class TextBuffer;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
-
 /** The Clipboard object represents a clipboard of data shared between different processes or between 
  * different widgets in the same process. Each clipboard is identified by a name encoded as a GdkAtom. *
  * (Conversion to and from strings can be done with gdk_atom_intern() and gdk_atom_name().) The default 
@@ -150,7 +145,7 @@ public:
    * 
    * (Passing Gdk::NONE is the same as using <tt>gdk_atom_intern
    * ("CLIPBOARD", <tt>false</tt>)</tt>. See 
-   * http://www.freedesktop.org/Standards/clipboards-spec
+   * http://www.freedesktop.org/standards/clipboards-spec/clipboards.txt
    * for a detailed discussion of the "CLIPBOARD" vs. "PRIMARY"
    * selections under the X window system. On Win32 the
    * Gdk::SELECTION_PRIMARY clipboard is essentially ignored.)
@@ -171,7 +166,7 @@ public:
    * it is owned by GTK+, must not be freed or
    * unrefd.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   static Glib::RefPtr<Clipboard> get_for_display(const Glib::RefPtr<Gdk::Display>& display, GdkAtom selection = GDK_SELECTION_CLIPBOARD);
 
@@ -179,14 +174,14 @@ public:
   /** Gets the Gdk::Display associated with @a clipboard 
    * @return The Gdk::Display associated with @a clipboard 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Gdk::Display> get_display();
   
   /** Gets the Gdk::Display associated with @a clipboard 
    * @return The Gdk::Display associated with @a clipboard 
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Gdk::Display> get_display() const;
 
@@ -260,7 +255,7 @@ public:
    * for the image, and for converting the image into the 
    * requested format.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param pixbuf A Gdk::Pixbuf.
    */
   void set_image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
@@ -300,24 +295,6 @@ public:
    */
   void request_text(const SlotTextReceived& slot);
   
-
-  /// For instance: void on_rich_text_received(const Glib::ustring& format, const std::string& text);
-  typedef sigc::slot<void, const Glib::ustring& , const std::string&> SlotRichTextReceived;
-
-  /** Requests the contents of the clipboard as rich text. When the rich text is later received, 
-   * callback will be called.
-   *
-   * The text parameter to the callback will contain the resulting rich text if the request succeeded, or 
-   * an empty string if it failed. This function can fail for various reasons, in particular if the 
-   * clipboard was empty or if the contents of the clipboard could not be converted into rich text form.
-   *
-   *
-   * @param slot:  a function to call when the text is received,
-   *             or the retrieval fails. (It will always be called
-   *             one way or the other.)
-   */
-  void request_rich_text(const Glib::RefPtr<TextBuffer>& buffer, const SlotRichTextReceived& slot);
-  
   
   /// For instance: void on_image_received(const Glib::RefPtr<Gdk::Pixbuf>& text);
   typedef sigc::slot<void, const Glib::RefPtr<Gdk::Pixbuf>&> SlotImageReceived;
@@ -355,7 +332,7 @@ public:
    *             is an intermediate type, so you should convert it to a
    *             standard C++ container.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   void request_targets(const SlotTargetsReceived& slot);
   
@@ -383,9 +360,6 @@ public:
    * clipboard could not be converted into text form.).
    */
   Glib::ustring wait_for_text() const;
-
-  std::string wait_for_rich_text(const Glib::RefPtr<TextBuffer>& buffer, std::string& format);
-  
   
   //Maybe the result should be const, but constness is not so clear-cut here. murrayc
   
@@ -400,7 +374,7 @@ public:
    * if the clipboard was empty or if the contents of 
    * the clipboard could not be converted into an image.)
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<Gdk::Pixbuf> wait_for_image() const;
   
@@ -418,8 +392,6 @@ public:
    */
   bool wait_is_text_available() const;
   
-  bool wait_is_rich_text_available(const Glib::RefPtr<TextBuffer>& buffer) const;
-  
   /** Test to see if there is an image available to be pasted
    * This is done by requesting the TARGETS atom and checking
    * if it contains any of the supported image targets. This function 
@@ -431,7 +403,7 @@ public:
    * the actual image data.
    * @return <tt>true</tt> is there is an image available, <tt>false</tt> otherwise.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool wait_is_image_available() const;  
   
@@ -444,7 +416,7 @@ public:
    * @param target A Gdk::Atom indicating which target to look for.
    * @return <tt>true</tt> if the target is available, <tt>false</tt> otherwise.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool wait_is_target_available(const Glib::ustring& target);
 
@@ -454,7 +426,7 @@ public:
    *
    * @result targets: The targets.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   Glib::StringArrayHandle wait_for_targets() const;
   
@@ -481,35 +453,20 @@ public:
   /** Stores the current clipboard data somewhere so that it will stay
    * around after the application has quit.
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void store();
-
-  //We use no_default_handler because this signal was added and we don't want to break the ABI by adding a virtual function.
-  
-/**
-   * @par Prototype:
-   * <tt>void %owner_change(GdkEventOwnerChange* event)</tt>
-   */
-
-  Glib::SignalProxy1< void,GdkEventOwnerChange* > signal_owner_change();
-
            
+
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/colorbutton.cc b/libs/gtkmm2/gtk/gtkmm/colorbutton.cc
index 6696319b15..15b2f5ddd1 100644
--- a/libs/gtkmm2/gtk/gtkmm/colorbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/colorbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/colorbutton.h>
 #include <gtkmm/private/colorbutton_p.h>
 
@@ -46,15 +45,13 @@ Gdk::Color ColorButton::get_color() const
 namespace
 {
 
-
-static const Glib::SignalProxyInfo ColorButton_signal_color_set_info =
+const Glib::SignalProxyInfo ColorButton_signal_color_set_info =
 {
   "color-set",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -99,18 +96,10 @@ void ColorButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->color_set = &color_set_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ColorButton_Class::color_set_callback(GtkColorButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -123,19 +112,15 @@ void ColorButton_Class::color_set_callback(GtkColorButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_color_set();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -148,7 +133,6 @@ void ColorButton_Class::color_set_callback(GtkColorButton* self)
       (*base->color_set)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ColorButton_Class::wrap_new(GObject* o)
@@ -206,12 +190,12 @@ ColorButton::ColorButton(const Gdk::Color& color)
 
 void ColorButton::set_color(const Gdk::Color& color)
 {
-gtk_color_button_set_color(gobj(), (color).gobj()); 
+  gtk_color_button_set_color(gobj(), (color).gobj());
 }
 
 void ColorButton::set_alpha(guint16 alpha)
 {
-gtk_color_button_set_alpha(gobj(), alpha); 
+  gtk_color_button_set_alpha(gobj(), alpha);
 }
 
 guint16 ColorButton::get_alpha() const
@@ -221,7 +205,7 @@ guint16 ColorButton::get_alpha() const
 
 void ColorButton::set_use_alpha(bool use_alpha)
 {
-gtk_color_button_set_use_alpha(gobj(), static_cast<int>(use_alpha)); 
+  gtk_color_button_set_use_alpha(gobj(), static_cast<int>(use_alpha));
 }
 
 bool ColorButton::get_use_alpha() const
@@ -231,7 +215,7 @@ bool ColorButton::get_use_alpha() const
 
 void ColorButton::set_title(const Glib::ustring& title)
 {
-gtk_color_button_set_title(gobj(), title.c_str()); 
+  gtk_color_button_set_title(gobj(), title.c_str());
 }
 
 Glib::ustring ColorButton::get_title() const
@@ -246,64 +230,47 @@ Glib::SignalProxy0< void > ColorButton::signal_color_set()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ColorButton::property_use_alpha() 
 {
   return Glib::PropertyProxy<bool>(this, "use-alpha");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ColorButton::property_use_alpha() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-alpha");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> ColorButton::property_title() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> ColorButton::property_title() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::Color> ColorButton::property_color() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> ColorButton::property_color() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint16> ColorButton::property_alpha() 
 {
   return Glib::PropertyProxy<guint16>(this, "alpha");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint16> ColorButton::property_alpha() const
 {
   return Glib::PropertyProxy_ReadOnly<guint16>(this, "alpha");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ColorButton::on_color_set()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -313,10 +280,6 @@ void Gtk::ColorButton::on_color_set()
   if(base && base->color_set)
     (*base->color_set)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/colorbutton.h b/libs/gtkmm2/gtk/gtkmm/colorbutton.h
index 214bad401a..aea0bc1d16 100644
--- a/libs/gtkmm2/gtk/gtkmm/colorbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/colorbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_COLORBUTTON_H
 #define _GTKMM_COLORBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -94,18 +93,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_color_set();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -119,7 +112,7 @@ public:
    * open, allowing the user to select a color. The swatch will be updated to reflect the
    * new color when the user finishes.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   ColorButton();
   
@@ -132,21 +125,21 @@ public:
    *
    * @param color A Gdk::Color to set the current color with.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   explicit ColorButton(const Gdk::Color& color);
 
   
   /** Sets the current color to be @a color .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param color A Gdk::Color to set the current color with.
    */
   void set_color(const Gdk::Color& color);
   
   /** Sets the current opacity to be @a alpha . 
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param alpha An integer between 0 and 65535.
    */
   void set_alpha(guint16 alpha);
@@ -157,7 +150,7 @@ public:
    *
    * @return A Gdk::Color representing the current internal color of the Gtk::ColorButton.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   Gdk::Color get_color() const;
   
@@ -165,13 +158,13 @@ public:
   /** Returns the current alpha value.
    * @return An integer between 0 and 65535.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   guint16 get_alpha() const;
   
   /** Sets whether or not the color button should use the alpha channel.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_alpha <tt>true</tt> if color button should use alpha channel, <tt>false</tt> if not.
    */
   void set_use_alpha(bool use_alpha = true);
@@ -179,35 +172,32 @@ public:
   /** Does the color selection dialog use the alpha channel?
    * @return <tt>true</tt> if the color sample uses alpha channel, <tt>false</tt> if not.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_use_alpha() const;
   
   /** Sets the title for the color selection dialog.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param title String containing new window title.
    */
   void set_title(const Glib::ustring& title);
   
   /** Gets the title of the color selection dialog.
+   * @return An internal string, do not free the return value
    * 
-   * @newin2p4
-   * @return The title.
+   * Since: 2.4.
    */
   Glib::ustring get_title() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether or not to give the color an alpha value.
+  /** Whether or not to give the color an alpha value.
    *
    * 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_use_alpha() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether or not to give the color an alpha value.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -215,19 +205,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_alpha() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The title of the color selection dialog.
+  /** The title of the color selection dialog.
    *
    * 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_title() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The title of the color selection dialog.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -235,19 +221,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The selected color.
+  /** The selected 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<Gdk::Color> property_color() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The selected color.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -255,19 +237,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_color() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The selected opacity value (0 fully transparent, 65535 fully opaque).
+  /** The selected opacity value (0 fully transparent, 65535 fully opaque).
    *
    * 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<guint16> property_alpha() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The selected opacity value (0 fully transparent, 65535 fully opaque).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -275,19 +253,8 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint16> property_alpha() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  /** The color_set signal is emitted when the user selects a color. When handling this signal,
-   * use get_color() and get_alpha() to find out which color 
-   * was just selected.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %color_set()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_color_set();
                     
 
@@ -305,8 +272,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ColorButton* wrap(GtkColorButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_COLORBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/colorselection.cc b/libs/gtkmm2/gtk/gtkmm/colorselection.cc
index 489b929c18..54525905bf 100644
--- a/libs/gtkmm2/gtk/gtkmm/colorselection.cc
+++ b/libs/gtkmm2/gtk/gtkmm/colorselection.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/colorselection.h>
 #include <gtkmm/private/colorselection_p.h>
 
@@ -31,29 +30,25 @@
 namespace
 {
 
-static Gtk::ColorSelection::SlotChangePaletteHook* global_change_palette_hook = 0;
+Gtk::ColorSelection::SlotChangePaletteHook* global_change_palette_hook = 0;
 
-static void global_change_palette_hook_callback(GdkScreen* screen, const GdkColor* colors, int n_colors)
+void global_change_palette_hook_callback(GdkScreen* screen, const GdkColor* colors, int n_colors)
 {
   g_return_if_fail(global_change_palette_hook != 0);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     (*global_change_palette_hook)(
         Glib::wrap(screen, true),
         Gdk::ArrayHandle_Color(colors, n_colors, Glib::OWNERSHIP_NONE));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void old_change_palette_hook_callback(const Glib::RefPtr<Gdk::Screen>& screen,
+void old_change_palette_hook_callback(const Glib::RefPtr<Gdk::Screen>& screen,
                                       const Gdk::ArrayHandle_Color&    colors,
                                       GtkColorSelectionChangePaletteWithScreenFunc func)
 {
@@ -121,15 +116,12 @@ ColorSelection::set_change_palette_hook(const ColorSelection::SlotChangePaletteH
 
   if(old_func)
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(old_func != &global_change_palette_hook_callback)
         old_slot = sigc::bind<-1>(sigc::ptr_fun(&old_change_palette_hook_callback), old_func);
       else if(global_change_palette_hook)
         old_slot = *global_change_palette_hook;
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
@@ -137,7 +129,6 @@ ColorSelection::set_change_palette_hook(const ColorSelection::SlotChangePaletteH
       delete new_slot;
       throw;
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   delete global_change_palette_hook;
@@ -152,15 +143,13 @@ ColorSelection::set_change_palette_hook(const ColorSelection::SlotChangePaletteH
 namespace
 {
 
-
-static const Glib::SignalProxyInfo ColorSelection_signal_color_changed_info =
+const Glib::SignalProxyInfo ColorSelection_signal_color_changed_info =
 {
   "color_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -205,18 +194,10 @@ void ColorSelection_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->color_changed = &color_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ColorSelection_Class::color_changed_callback(GtkColorSelection* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -229,19 +210,15 @@ void ColorSelection_Class::color_changed_callback(GtkColorSelection* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_color_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -254,7 +231,6 @@ void ColorSelection_Class::color_changed_callback(GtkColorSelection* self)
       (*base->color_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ColorSelection_Class::wrap_new(GObject* o)
@@ -310,7 +286,7 @@ bool ColorSelection::get_has_opacity_control() const
 
 void ColorSelection::set_has_opacity_control(bool has_opacity)
 {
-gtk_color_selection_set_has_opacity_control(gobj(), static_cast<int>(has_opacity)); 
+  gtk_color_selection_set_has_opacity_control(gobj(), static_cast<int>(has_opacity));
 }
 
 bool ColorSelection::get_has_palette() const
@@ -320,17 +296,17 @@ bool ColorSelection::get_has_palette() const
 
 void ColorSelection::set_has_palette(bool has_palette)
 {
-gtk_color_selection_set_has_palette(gobj(), static_cast<int>(has_palette)); 
+  gtk_color_selection_set_has_palette(gobj(), static_cast<int>(has_palette));
 }
 
 void ColorSelection::set_current_color(const Gdk::Color& color)
 {
-gtk_color_selection_set_current_color(gobj(), (color).gobj()); 
+  gtk_color_selection_set_current_color(gobj(), (color).gobj());
 }
 
 void ColorSelection::set_current_alpha(guint16 alpha)
 {
-gtk_color_selection_set_current_alpha(gobj(), alpha); 
+  gtk_color_selection_set_current_alpha(gobj(), alpha);
 }
 
 guint16 ColorSelection::get_current_alpha() const
@@ -340,12 +316,12 @@ guint16 ColorSelection::get_current_alpha() const
 
 void ColorSelection::set_previous_color(const Gdk::Color& color)
 {
-gtk_color_selection_set_previous_color(gobj(), (color).gobj()); 
+  gtk_color_selection_set_previous_color(gobj(), (color).gobj());
 }
 
 void ColorSelection::set_previous_alpha(guint16 alpha)
 {
-gtk_color_selection_set_previous_alpha(gobj(), alpha); 
+  gtk_color_selection_set_previous_alpha(gobj(), alpha);
 }
 
 guint16 ColorSelection::get_previous_alpha() const
@@ -365,64 +341,47 @@ Glib::SignalProxy0< void > ColorSelection::signal_color_changed()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ColorSelection::property_has_palette() 
 {
   return Glib::PropertyProxy<bool>(this, "has-palette");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ColorSelection::property_has_palette() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-palette");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ColorSelection::property_has_opacity_control() 
 {
   return Glib::PropertyProxy<bool>(this, "has-opacity-control");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ColorSelection::property_has_opacity_control() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-opacity-control");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::Color> ColorSelection::property_current_color() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "current-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> ColorSelection::property_current_color() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "current-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> ColorSelection::property_current_alpha() 
 {
   return Glib::PropertyProxy<guint>(this, "current-alpha");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> ColorSelection::property_current_alpha() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "current-alpha");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ColorSelection::on_color_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -432,10 +391,6 @@ void Gtk::ColorSelection::on_color_changed()
   if(base && base->color_changed)
     (*base->color_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -482,19 +437,8 @@ void ColorSelectionDialog_Class::class_init_function(void* g_class, void* class_
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ColorSelectionDialog_Class::wrap_new(GObject* o)
 {
@@ -548,7 +492,7 @@ ColorSelectionDialog::ColorSelectionDialog(const Glib::ustring& title)
 {
   }
 
- ColorSelection* ColorSelectionDialog::get_colorsel()
+ColorSelection* ColorSelectionDialog::get_colorsel()
 {
   return Glib::wrap((GtkColorSelection*)(gobj()->colorsel));
 }
@@ -557,8 +501,8 @@ const ColorSelection* ColorSelectionDialog::get_colorsel() const
 {
   return Glib::wrap((GtkColorSelection*)(gobj()->colorsel));
 }
- 
- Button* ColorSelectionDialog::get_ok_button()
+
+Button* ColorSelectionDialog::get_ok_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->ok_button));
 }
@@ -567,8 +511,8 @@ const Button* ColorSelectionDialog::get_ok_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->ok_button));
 }
- 
- Button* ColorSelectionDialog::get_cancel_button()
+
+Button* ColorSelectionDialog::get_cancel_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->cancel_button));
 }
@@ -577,8 +521,8 @@ const Button* ColorSelectionDialog::get_cancel_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->cancel_button));
 }
- 
- Button* ColorSelectionDialog::get_help_button()
+
+Button* ColorSelectionDialog::get_help_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->help_button));
 }
@@ -587,13 +531,6 @@ const Button* ColorSelectionDialog::get_help_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->help_button));
 }
- 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/colorselection.h b/libs/gtkmm2/gtk/gtkmm/colorselection.h
index 718565383c..0d77feb43e 100644
--- a/libs/gtkmm2/gtk/gtkmm/colorselection.h
+++ b/libs/gtkmm2/gtk/gtkmm/colorselection.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_COLORSELECTION_H
 #define _GTKMM_COLORSELECTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -105,18 +104,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_color_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -200,25 +193,17 @@ public:
   static SlotChangePaletteHook set_change_palette_hook(const SlotChangePaletteHook& slot);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %color_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_color_changed();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether a palette should be used.
+  /** Whether a palette should be used.
    *
    * 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_has_palette() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether a palette should be used.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -226,19 +211,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_palette() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the color selector should allow setting opacity.
+  /** Whether the color selector should allow setting opacity.
    *
    * 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_has_opacity_control() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the color selector should allow setting opacity.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -246,19 +227,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_opacity_control() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current color.
+  /** The current 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<Gdk::Color> property_current_color() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The current color.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -266,19 +243,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_current_color() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current opacity value (0 fully transparent, 65535 fully opaque).
+  /** The current opacity value (0 fully transparent, 65535 fully opaque).
    *
    * 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_current_alpha() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The current opacity value (0 fully transparent, 65535 fully opaque).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -286,7 +259,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_current_alpha() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -338,17 +310,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -359,15 +325,15 @@ public:
   ColorSelectionDialog();
   explicit ColorSelectionDialog(const Glib::ustring& title);
 
-   ColorSelection* get_colorsel();
+  ColorSelection* get_colorsel();
   const ColorSelection* get_colorsel() const;
-    Button* get_ok_button();
+  Button* get_ok_button();
   const Button* get_ok_button() const;
-    Button* get_cancel_button();
+  Button* get_cancel_button();
   const Button* get_cancel_button() const;
-    Button* get_help_button();
+  Button* get_help_button();
   const Button* get_help_button() const;
- 
+
 
 };
 
@@ -382,9 +348,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ColorSelection* wrap(GtkColorSelection* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::ColorSelectionDialog
@@ -393,8 +357,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ColorSelectionDialog* wrap(GtkColorSelectionDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_COLORSELECTION_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/combo.cc b/libs/gtkmm2/gtk/gtkmm/combo.cc
index c36c030ace..453c7ec39e 100644
--- a/libs/gtkmm2/gtk/gtkmm/combo.cc
+++ b/libs/gtkmm2/gtk/gtkmm/combo.cc
@@ -1,8 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <gtkmm/combo.h>
 #include <gtkmm/private/combo_p.h>
 
@@ -139,8 +136,7 @@ Glib::ListHandle<Glib::ustring> Combo::get_popdown_strings() const
 namespace
 {
 
-
-static void ComboDropDownItem_signal_scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0,gfloat p1,void* data)
+void ComboDropDownItem_signal_scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0,gfloat p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,ScrollType,float > SlotType;
@@ -148,25 +144,21 @@ static void ComboDropDownItem_signal_scroll_horizontal_callback(GtkListItem* sel
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_horizontal_info =
+const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_horizontal_info =
 {
   "scroll-horizontal",
   (GCallback) &ComboDropDownItem_signal_scroll_horizontal_callback,
@@ -174,7 +166,7 @@ static const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_horizontal_in
 };
 
 
-static void ComboDropDownItem_signal_scroll_vertical_callback(GtkListItem* self, GtkScrollType p0,gfloat p1,void* data)
+void ComboDropDownItem_signal_scroll_vertical_callback(GtkListItem* self, GtkScrollType p0,gfloat p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,ScrollType,float > SlotType;
@@ -182,25 +174,21 @@ static void ComboDropDownItem_signal_scroll_vertical_callback(GtkListItem* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_vertical_info =
+const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_vertical_info =
 {
   "scroll-vertical",
   (GCallback) &ComboDropDownItem_signal_scroll_vertical_callback,
@@ -208,7 +196,7 @@ static const Glib::SignalProxyInfo ComboDropDownItem_signal_scroll_vertical_info
 };
 
 
-static void ComboDropDown_signal_select_child_callback(GtkList* self, GtkWidget* p0,void* data)
+void ComboDropDown_signal_select_child_callback(GtkList* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget& > SlotType;
@@ -216,24 +204,20 @@ static void ComboDropDown_signal_select_child_callback(GtkList* self, GtkWidget*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(*Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ComboDropDown_signal_select_child_info =
+const Glib::SignalProxyInfo ComboDropDown_signal_select_child_info =
 {
   "select_child",
   (GCallback) &ComboDropDown_signal_select_child_callback,
@@ -241,7 +225,7 @@ static const Glib::SignalProxyInfo ComboDropDown_signal_select_child_info =
 };
 
 
-static const Glib::SignalProxyInfo ComboDropDown_signal_selection_changed_info =
+const Glib::SignalProxyInfo ComboDropDown_signal_selection_changed_info =
 {
   "selection_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -249,7 +233,7 @@ static const Glib::SignalProxyInfo ComboDropDown_signal_selection_changed_info =
 };
 
 
-static void ComboDropDown_signal_unselect_child_callback(GtkList* self, GtkWidget* p0,void* data)
+void ComboDropDown_signal_unselect_child_callback(GtkList* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget& > SlotType;
@@ -257,31 +241,26 @@ static void ComboDropDown_signal_unselect_child_callback(GtkList* self, GtkWidge
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(*Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo ComboDropDown_signal_unselect_child_info =
+const Glib::SignalProxyInfo ComboDropDown_signal_unselect_child_info =
 {
   "unselect_child",
   (GCallback) &ComboDropDown_signal_unselect_child_callback,
   (GCallback) &ComboDropDown_signal_unselect_child_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -326,19 +305,11 @@ void ComboDropDownItem_Class::class_init_function(void* g_class, void* class_dat
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->scroll_horizontal = &scroll_horizontal_callback;
   klass->scroll_vertical = &scroll_vertical_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ComboDropDownItem_Class::scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0, gfloat p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -351,21 +322,17 @@ void ComboDropDownItem_Class::scroll_horizontal_callback(GtkListItem* self, GtkS
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_scroll_horizontal(((ScrollType)(p0))
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -378,6 +345,7 @@ void ComboDropDownItem_Class::scroll_horizontal_callback(GtkListItem* self, GtkS
       (*base->scroll_horizontal)(self, p0, p1);
   }
 }
+
 void ComboDropDownItem_Class::scroll_vertical_callback(GtkListItem* self, GtkScrollType p0, gfloat p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -390,21 +358,17 @@ void ComboDropDownItem_Class::scroll_vertical_callback(GtkListItem* self, GtkScr
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_scroll_vertical(((ScrollType)(p0))
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -417,7 +381,6 @@ void ComboDropDownItem_Class::scroll_vertical_callback(GtkListItem* self, GtkScr
       (*base->scroll_vertical)(self, p0, p1);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ComboDropDownItem_Class::wrap_new(GObject* o)
@@ -472,14 +435,12 @@ Glib::SignalProxy2< void,ScrollType,float > ComboDropDownItem::signal_scroll_hor
   return Glib::SignalProxy2< void,ScrollType,float >(this, &ComboDropDownItem_signal_scroll_horizontal_info);
 }
 
-
 Glib::SignalProxy2< void,ScrollType,float > ComboDropDownItem::signal_scroll_vertical()
 {
   return Glib::SignalProxy2< void,ScrollType,float >(this, &ComboDropDownItem_signal_scroll_vertical_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ComboDropDownItem::on_scroll_horizontal(ScrollType scroll_type, float position)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -489,6 +450,7 @@ void Gtk::ComboDropDownItem::on_scroll_horizontal(ScrollType scroll_type, float
   if(base && base->scroll_horizontal)
     (*base->scroll_horizontal)(gobj(),((GtkScrollType)(scroll_type)),position);
 }
+
 void Gtk::ComboDropDownItem::on_scroll_vertical(ScrollType scroll_type, float position)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -498,10 +460,6 @@ void Gtk::ComboDropDownItem::on_scroll_vertical(ScrollType scroll_type, float po
   if(base && base->scroll_vertical)
     (*base->scroll_vertical)(gobj(),((GtkScrollType)(scroll_type)),position);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -548,20 +506,12 @@ void ComboDropDown_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->select_child = &select_child_callback;
   klass->selection_changed = &selection_changed_callback;
   klass->unselect_child = &unselect_child_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ComboDropDown_Class::select_child_callback(GtkList* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -574,20 +524,16 @@ void ComboDropDown_Class::select_child_callback(GtkList* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_select_child(*Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -600,6 +546,7 @@ void ComboDropDown_Class::select_child_callback(GtkList* self, GtkWidget* p0)
       (*base->select_child)(self, p0);
   }
 }
+
 void ComboDropDown_Class::selection_changed_callback(GtkList* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -612,19 +559,15 @@ void ComboDropDown_Class::selection_changed_callback(GtkList* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_selection_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -637,6 +580,7 @@ void ComboDropDown_Class::selection_changed_callback(GtkList* self)
       (*base->selection_changed)(self);
   }
 }
+
 void ComboDropDown_Class::unselect_child_callback(GtkList* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -649,20 +593,16 @@ void ComboDropDown_Class::unselect_child_callback(GtkList* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_unselect_child(*Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -675,7 +615,6 @@ void ComboDropDown_Class::unselect_child_callback(GtkList* self, GtkWidget* p0)
       (*base->unselect_child)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ComboDropDown_Class::wrap_new(GObject* o)
@@ -794,12 +733,12 @@ ComboDropDown::ComboDropDown()
 
 void ComboDropDown::scroll_horizontal(ScrollType scroll_type, float position)
 {
-gtk_list_scroll_horizontal(gobj(), ((GtkScrollType)(scroll_type)), position); 
+  gtk_list_scroll_horizontal(gobj(), ((GtkScrollType)(scroll_type)), position);
 }
 
 void ComboDropDown::scroll_vertical(ScrollType scroll_type, float position)
 {
-gtk_list_scroll_vertical(gobj(), ((GtkScrollType)(scroll_type)), position); 
+  gtk_list_scroll_vertical(gobj(), ((GtkScrollType)(scroll_type)), position);
 }
 
 
@@ -808,20 +747,17 @@ Glib::SignalProxy1< void,Widget& > ComboDropDown::signal_select_child()
   return Glib::SignalProxy1< void,Widget& >(this, &ComboDropDown_signal_select_child_info);
 }
 
-
 Glib::SignalProxy0< void > ComboDropDown::signal_selection_changed()
 {
   return Glib::SignalProxy0< void >(this, &ComboDropDown_signal_selection_changed_info);
 }
 
-
 Glib::SignalProxy1< void,Widget& > ComboDropDown::signal_unselect_child()
 {
   return Glib::SignalProxy1< void,Widget& >(this, &ComboDropDown_signal_unselect_child_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ComboDropDown::on_select_child(Widget& item)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -831,6 +767,7 @@ void Gtk::ComboDropDown::on_select_child(Widget& item)
   if(base && base->select_child)
     (*base->select_child)(gobj(),(item).gobj());
 }
+
 void Gtk::ComboDropDown::on_selection_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -840,6 +777,7 @@ void Gtk::ComboDropDown::on_selection_changed()
   if(base && base->selection_changed)
     (*base->selection_changed)(gobj());
 }
+
 void Gtk::ComboDropDown::on_unselect_child(Widget& item)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -849,10 +787,6 @@ void Gtk::ComboDropDown::on_unselect_child(Widget& item)
   if(base && base->unselect_child)
     (*base->unselect_child)(gobj(),(item).gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -899,19 +833,8 @@ void Combo_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Combo_Class::wrap_new(GObject* o)
 {
@@ -960,40 +883,40 @@ Combo::Combo()
 
 void Combo::set_value_in_list(bool value, bool empty)
 {
-gtk_combo_set_value_in_list(gobj(), static_cast<int>(value), static_cast<int>(empty)); 
+  gtk_combo_set_value_in_list(gobj(), static_cast<int>(value), static_cast<int>(empty));
 }
 
 void Combo::set_use_arrows(bool arrows_on)
 {
-gtk_combo_set_use_arrows(gobj(), static_cast<int>(arrows_on)); 
+  gtk_combo_set_use_arrows(gobj(), static_cast<int>(arrows_on));
 }
 
 void Combo::set_use_arrows_always(bool arrows_always)
 {
-gtk_combo_set_use_arrows_always(gobj(), static_cast<int>(arrows_always)); 
+  gtk_combo_set_use_arrows_always(gobj(), static_cast<int>(arrows_always));
 }
 
 void Combo::set_case_sensitive(bool val)
 {
-gtk_combo_set_case_sensitive(gobj(), static_cast<int>(val)); 
+  gtk_combo_set_case_sensitive(gobj(), static_cast<int>(val));
 }
 
 void Combo::set_item_string(Gtk::Item& item, const Glib::ustring& item_value)
 {
-gtk_combo_set_item_string(gobj(), (item).gobj(), item_value.c_str()); 
+  gtk_combo_set_item_string(gobj(), (item).gobj(), item_value.c_str());
 }
 
 void Combo::set_popdown_strings(const Glib::ListHandle<Glib::ustring>& strings)
 {
-gtk_combo_set_popdown_strings(gobj(), strings.data()); 
+  gtk_combo_set_popdown_strings(gobj(), strings.data());
 }
 
 void Combo::disable_activate()
 {
-gtk_combo_disable_activate(gobj()); 
+  gtk_combo_disable_activate(gobj());
 }
 
- Entry* Combo::get_entry()
+Entry* Combo::get_entry()
 {
   return Glib::wrap((GtkEntry*)(gobj()->entry));
 }
@@ -1002,8 +925,8 @@ const Entry* Combo::get_entry() const
 {
   return Glib::wrap((GtkEntry*)(gobj()->entry));
 }
- 
- ComboDropDown* Combo::get_list()
+
+ComboDropDown* Combo::get_list()
 {
   return Glib::wrap((GtkList*)(gobj()->list));
 }
@@ -1012,88 +935,59 @@ const ComboDropDown* Combo::get_list() const
 {
   return Glib::wrap((GtkList*)(gobj()->list));
 }
- 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+
 Glib::PropertyProxy<bool> Combo::property_enable_arrow_keys() 
 {
   return Glib::PropertyProxy<bool>(this, "enable-arrow-keys");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Combo::property_enable_arrow_keys() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-arrow-keys");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Combo::property_enable_arrows_always() 
 {
   return Glib::PropertyProxy<bool>(this, "enable-arrows-always");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Combo::property_enable_arrows_always() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-arrows-always");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Combo::property_case_sensitive() 
 {
   return Glib::PropertyProxy<bool>(this, "case-sensitive");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Combo::property_case_sensitive() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "case-sensitive");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Combo::property_allow_empty() 
 {
   return Glib::PropertyProxy<bool>(this, "allow-empty");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Combo::property_allow_empty() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "allow-empty");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Combo::property_value_in_list() 
 {
   return Glib::PropertyProxy<bool>(this, "value-in-list");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Combo::property_value_in_list() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "value-in-list");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
diff --git a/libs/gtkmm2/gtk/gtkmm/combo.h b/libs/gtkmm2/gtk/gtkmm/combo.h
index efbb772495..d0c973204d 100644
--- a/libs/gtkmm2/gtk/gtkmm/combo.h
+++ b/libs/gtkmm2/gtk/gtkmm/combo.h
@@ -3,9 +3,6 @@
 #ifndef _GTKMM_COMBO_H
 #define _GTKMM_COMBO_H
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -115,19 +112,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_scroll_horizontal(ScrollType scroll_type, float position);
   virtual void on_scroll_vertical(ScrollType scroll_type, float position);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -137,19 +128,9 @@ public:
   ComboDropDownItem();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %scroll_horizontal(ScrollType scroll_type, float position)</tt>
-   */
-
   Glib::SignalProxy2< void,ScrollType,float > signal_scroll_horizontal();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %scroll_vertical(ScrollType scroll_type, float position)</tt>
-   */
-
   Glib::SignalProxy2< void,ScrollType,float > signal_scroll_vertical();
 
 
@@ -268,20 +249,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_select_child(Widget& item);
   virtual void on_selection_changed();
   virtual void on_unselect_child(Widget& item);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -304,27 +279,12 @@ public:
   const ComboDropDownList& children() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %select_child(Widget& item)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget& > signal_select_child();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %selection_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_selection_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %unselect_child(Widget& item)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget& > signal_unselect_child();
 
 
@@ -394,26 +354,20 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
 
-  
 public:
 
   Combo();
   
+
   /** Allow direct text entry
    * Whether the text in the entry must be or not be in the list.
    *
@@ -468,22 +422,19 @@ public:
   
   void disable_activate();
 
-   Entry* get_entry();
+  Entry* get_entry();
   const Entry* get_entry() const;
-    ComboDropDown* get_list();
+  ComboDropDown* get_list();
   const ComboDropDown* get_list() const;
- 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the arrow keys move through the list of items.
+
+  /** Whether the arrow keys move through the list of items.
    *
    * 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_enable_arrow_keys() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the arrow keys move through the list of items.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -491,19 +442,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_enable_arrow_keys() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Obsolete property
+  /** Obsolete property
    *
    * 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_enable_arrows_always() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Obsolete property
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -511,19 +458,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_enable_arrows_always() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether list item matching is case sensitive.
+  /** Whether list item matching is case sensitive.
    *
    * 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_case_sensitive() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether list item matching is case sensitive.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -531,19 +474,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_case_sensitive() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether an empty value may be entered in this field.
+  /** Whether an empty value may be entered in this field.
    *
    * 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_allow_empty() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether an empty value may be entered in this field.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -551,19 +490,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_allow_empty() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether entered values must already be present in the list.
+  /** Whether entered values must already be present in the list.
    *
    * 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_value_in_list() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether entered values must already be present in the list.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -571,7 +506,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_value_in_list() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -588,9 +522,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ComboDropDownItem* wrap(GtkListItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::ComboDropDown
@@ -599,9 +531,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ComboDropDown* wrap(GtkList* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::Combo
@@ -610,11 +540,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Combo* wrap(GtkCombo* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
+}
 #endif /* _GTKMM_COMBO_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/combobox.cc b/libs/gtkmm2/gtk/gtkmm/combobox.cc
index b56d24e2ba..d16c27d274 100644
--- a/libs/gtkmm2/gtk/gtkmm/combobox.cc
+++ b/libs/gtkmm2/gtk/gtkmm/combobox.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/combobox.h>
 #include <gtkmm/private/combobox_p.h>
 
@@ -25,7 +24,7 @@
  * License along with this library; if not, write to the Free
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
-
+ 
 #include <gtkmm/liststore.h>
 #include <gtkmm/cellrenderertext.h>
 #include <gtkmm/treeview_private.h> //For SignalProxy_RowSeparator.
@@ -75,13 +74,13 @@ TreeModel::const_iterator ComboBox::get_active() const
 
 void ComboBox::set_row_separator_func(const SlotRowSeparator& slot)
 {
-  //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  //It will be deleted when SignalProxy_RowSeparator_gtk_callback_destroy() is called.
-  SlotRowSeparator* slot_copy = new SlotRowSeparator(slot);
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_RowSeparator::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_RowSeparator *const pSignalProxy = new TreeView_Private::SignalProxy_RowSeparator(slot);
 
   gtk_combo_box_set_row_separator_func(gobj(),
-      &TreeView_Private::SignalProxy_RowSeparator_gtk_callback, slot_copy,
-      &TreeView_Private::SignalProxy_RowSeparator_gtk_callback_destroy);
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback_destroy);
 }
 
 void ComboBox::unset_row_separator_func()
@@ -95,15 +94,13 @@ void ComboBox::unset_row_separator_func()
 namespace
 {
 
-
-static const Glib::SignalProxyInfo ComboBox_signal_changed_info =
+const Glib::SignalProxyInfo ComboBox_signal_changed_info =
 {
   "changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -149,18 +146,10 @@ void ComboBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->changed = &changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ComboBox_Class::changed_callback(GtkComboBox* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -173,19 +162,15 @@ void ComboBox_Class::changed_callback(GtkComboBox* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -198,7 +183,6 @@ void ComboBox_Class::changed_callback(GtkComboBox* self)
       (*base->changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ComboBox_Class::wrap_new(GObject* o)
@@ -256,7 +240,7 @@ ComboBox::ComboBox(const Glib::RefPtr<TreeModel>& model)
 
 void ComboBox::set_wrap_width(int width)
 {
-gtk_combo_box_set_wrap_width(gobj(), width); 
+  gtk_combo_box_set_wrap_width(gobj(), width);
 }
 
 int ComboBox::get_wrap_width() const
@@ -266,7 +250,7 @@ int ComboBox::get_wrap_width() const
 
 void ComboBox::set_row_span_column(int row_span)
 {
-gtk_combo_box_set_row_span_column(gobj(), row_span); 
+  gtk_combo_box_set_row_span_column(gobj(), row_span);
 }
 
 int ComboBox::get_row_span_column() const
@@ -276,7 +260,7 @@ int ComboBox::get_row_span_column() const
 
 void ComboBox::set_column_span_column(int column_span)
 {
-gtk_combo_box_set_column_span_column(gobj(), column_span); 
+  gtk_combo_box_set_column_span_column(gobj(), column_span);
 }
 
 int ComboBox::get_column_span_column() const
@@ -291,17 +275,7 @@ bool ComboBox::get_add_tearoffs() const
 
 void ComboBox::set_add_tearoffs(bool add_tearoffs)
 {
-gtk_combo_box_set_add_tearoffs(gobj(), static_cast<int>(add_tearoffs)); 
-}
-
-Glib::ustring ComboBox::get_title() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_combo_box_get_title(const_cast<GtkComboBox*>(gobj())));
-}
-
-void ComboBox::set_title(const Glib::ustring& title)
-{
-gtk_combo_box_set_title(gobj(), title.c_str()); 
+  gtk_combo_box_set_add_tearoffs(gobj(), static_cast<int>(add_tearoffs));
 }
 
 bool ComboBox::get_focus_on_click() const
@@ -311,7 +285,7 @@ bool ComboBox::get_focus_on_click() const
 
 void ComboBox::set_focus_on_click(bool focus_on_click)
 {
-gtk_combo_box_set_focus_on_click(gobj(), static_cast<int>(focus_on_click)); 
+  gtk_combo_box_set_focus_on_click(gobj(), static_cast<int>(focus_on_click));
 }
 
 int ComboBox::get_active_row_number() const
@@ -321,196 +295,147 @@ int ComboBox::get_active_row_number() const
 
 void ComboBox::set_active(int index)
 {
-gtk_combo_box_set_active(gobj(), index); 
+  gtk_combo_box_set_active(gobj(), index);
 }
 
 void ComboBox::set_active(const TreeModel::iterator& iter)
 {
-gtk_combo_box_set_active_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj())); 
+  gtk_combo_box_set_active_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj()));
 }
 
 Glib::RefPtr<TreeModel> ComboBox::get_model()
 {
 
   Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_combo_box_get_model(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TreeModel> ComboBox::get_model() const
 {
-  return const_cast<ComboBox*>(this)->get_model();
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_combo_box_get_model(const_cast<GtkComboBox*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void ComboBox::set_model(const Glib::RefPtr<TreeModel>& model)
 {
-gtk_combo_box_set_model(gobj(), Glib::unwrap(model)); 
+  gtk_combo_box_set_model(gobj(), Glib::unwrap(model));
 }
 
 void ComboBox::popup()
 {
-gtk_combo_box_popup(gobj()); 
+  gtk_combo_box_popup(gobj());
 }
 
 void ComboBox::popdown()
 {
-gtk_combo_box_popdown(gobj()); 
+  gtk_combo_box_popdown(gobj());
 }
 
-#ifdef GTKMM_ATKMM_ENABLED
 Glib::RefPtr<Atk::Object> ComboBox::get_popup_accessible()
 {
   return Glib::wrap(gtk_combo_box_get_popup_accessible(gobj()));
 }
 
-
-#endif // GTKMM_ATKMM_ENABLED
-#ifdef GTKMM_ATKMM_ENABLED
 Glib::RefPtr<const Atk::Object> ComboBox::get_popup_accessible() const
 {
-  return const_cast<ComboBox*>(this)->get_popup_accessible();
+  return Glib::wrap(gtk_combo_box_get_popup_accessible(const_cast<GtkComboBox*>(gobj())));
 }
 
 
-#endif // GTKMM_ATKMM_ENABLED
-
-
 Glib::SignalProxy0< void > ComboBox::signal_changed()
 {
   return Glib::SignalProxy0< void >(this, &ComboBox_signal_changed_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<TreeModel> > ComboBox::property_model() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > ComboBox::property_model() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> ComboBox::property_wrap_width() 
 {
   return Glib::PropertyProxy<int>(this, "wrap-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> ComboBox::property_wrap_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "wrap-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> ComboBox::property_row_span_column() 
 {
   return Glib::PropertyProxy<int>(this, "row-span-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> ComboBox::property_row_span_column() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "row-span-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> ComboBox::property_column_span_column() 
 {
   return Glib::PropertyProxy<int>(this, "column-span-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> ComboBox::property_column_span_column() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "column-span-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> ComboBox::property_active() 
 {
   return Glib::PropertyProxy<int>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> ComboBox::property_active() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ComboBox::property_add_tearoffs() 
 {
   return Glib::PropertyProxy<bool>(this, "add-tearoffs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ComboBox::property_add_tearoffs() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "add-tearoffs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ComboBox::property_has_frame() 
 {
   return Glib::PropertyProxy<bool>(this, "has-frame");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ComboBox::property_has_frame() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-frame");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ComboBox::property_focus_on_click() 
 {
   return Glib::PropertyProxy<bool>(this, "focus-on-click");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ComboBox::property_focus_on_click() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "focus-on-click");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> ComboBox::property_tearoff_title() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "tearoff-title");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> ComboBox::property_tearoff_title() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "tearoff-title");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ComboBox::on_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -520,10 +445,6 @@ void Gtk::ComboBox::on_changed()
   if(base && base->changed)
     (*base->changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/combobox.h b/libs/gtkmm2/gtk/gtkmm/combobox.h
index 2201940cec..c143e59bc2 100644
--- a/libs/gtkmm2/gtk/gtkmm/combobox.h
+++ b/libs/gtkmm2/gtk/gtkmm/combobox.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_COMBOBOX_H
 #define _GTKMM_COMBOBOX_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -66,7 +65,6 @@ namespace Gtk
 class ComboBox
 : public Bin,
   public CellLayout
-//TODO: Since GTK+ 2.6, this should now inherit also from CellEditable, but we can't add this base without breaking ABI.
 {
   public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -109,18 +107,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -139,7 +131,7 @@ public:
    * the preferred number of columns when you want the popup to be layed out
    * in a table.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param width Preferred number of columns.
    */
   void set_wrap_width(int width);
@@ -149,7 +141,7 @@ public:
    * 1, the combo box is in table mode.
    * @return The wrap width.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_wrap_width() const;
 
@@ -158,7 +150,7 @@ public:
    * The row span column contains integers which indicate how many rows
    * an item should span.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param row_span A column in the model passed during construction.
    */
   void set_row_span_column(int row_span);
@@ -166,7 +158,7 @@ public:
   /** Returns the column with row span information for @a combo_box .
    * @return The row span column.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_row_span_column() const;
 
@@ -175,7 +167,7 @@ public:
    *  @a column_span . The column span column contains integers which indicate
    * how many columns an item should span.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param column_span A column in the model passed during construction.
    */
   void set_column_span_column(int column_span);
@@ -183,7 +175,7 @@ public:
   /** Returns the column with column span information for @a combo_box .
    * @return The column span column.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_column_span_column() const;
 
@@ -196,23 +188,18 @@ public:
   /** Sets whether the popup menu should have a tearoff 
    * menu item.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param add_tearoffs <tt>true</tt> to add tearoff menu items.
    */
   void set_add_tearoffs(bool add_tearoffs = true);
 
   
-  Glib::ustring get_title() const;
-  
-  void set_title(const Glib::ustring& title);
-
-  
   /** Returns whether the combo box grabs focus when it is clicked 
    * with the mouse. See set_focus_on_click().
    * @return <tt>true</tt> if the combo box grabs focus when it is 
    * clicked with the mouse.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_focus_on_click() const;
   
@@ -221,7 +208,7 @@ public:
    * like toolbars where you don't want the keyboard focus removed from 
    * the main area of the application.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param focus_on_click Whether the combo box grabs focus when clicked 
    * with the mouse.
    */
@@ -237,7 +224,7 @@ public:
    * @return An integer which is the index of the currently active item, or
    * -1 if there's no active item.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_active_row_number() const;
 
@@ -254,7 +241,7 @@ public:
     
   /** Sets the active item of @a combo_box  to be the item at @a index .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param index An index in the model passed during construction, or -1 to have
    * no active item.
    */
@@ -263,7 +250,7 @@ public:
   /** Sets the current active item to be the one referenced by @a iter . 
    *  @a iter  must correspond to a path of depth one.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param iter The Gtk::TreeIter.
    */
   void set_active(const TreeModel::iterator& iter);
@@ -276,14 +263,14 @@ public:
   /** Returns the Gtk::TreeModel which is acting as data source for @a combo_box .
    * @return A Gtk::TreeModel which was passed during construction.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<TreeModel> get_model();
   
   /** Returns the Gtk::TreeModel which is acting as data source for @a combo_box .
    * @return A Gtk::TreeModel which was passed during construction.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const TreeModel> get_model() const;
   
@@ -294,7 +281,7 @@ public:
    * call gtk_combo_box_cell_layout_clear() yourself if you need to set up 
    * different cell renderers for the new model.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param model A Gtk::TreeModel.
    */
   void set_model(const Glib::RefPtr<TreeModel>& model);
@@ -318,7 +305,7 @@ public:
    * This function is mostly intended for use by accessibility technologies;
    * applications should have little use for it.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void popup();
   
@@ -327,10 +314,10 @@ public:
    * This function is mostly intended for use by accessibility technologies;
    * applications should have little use for it.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void popdown();
-
+    
   
   /** Gets the accessible object corresponding to the combo box's popup.
    * 
@@ -338,13 +325,9 @@ public:
    * applications should have little use for it.
    * @return The accessible object corresponding to the combo box's popup.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
-
-#ifdef  GTKMM_ATKMM_ENABLED
   Glib::RefPtr<Atk::Object> get_popup_accessible();
-#endif //  GTKMM_ATKMM_ENABLED
-
   
   /** Gets the accessible object corresponding to the combo box's popup.
    * 
@@ -352,27 +335,20 @@ public:
    * applications should have little use for it.
    * @return The accessible object corresponding to the combo box's popup.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
-
-#ifdef  GTKMM_ATKMM_ENABLED
   Glib::RefPtr<const Atk::Object> get_popup_accessible() const;
-#endif //  GTKMM_ATKMM_ENABLED
-
 
    //These are in ComboBoxText.
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The model for the combo box.
+  /** The model for the combo box.
    *
    * 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<TreeModel> > property_model() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The model for the combo box.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -380,39 +356,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > property_model() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Wrap width for laying out the items in a grid.
+  /** Wrap width for layouting the items in a grid.
    *
    * 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_wrap_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Wrap width for laying out the items in a grid.
+/** Wrap width for layouting the items in a grid.
    *
    * 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_wrap_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TreeModel column containing the row span values.
+  /** TreeModel column containing the row span values.
    *
    * 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_row_span_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** TreeModel column containing the row span values.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -420,19 +388,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_row_span_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TreeModel column containing the column span values.
+  /** TreeModel column containing the column span values.
    *
    * 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_column_span_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** TreeModel column containing the column span values.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -440,19 +404,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_column_span_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The item which is currently active.
+  /** The item which is currently active.
    *
    * 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_active() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The item which is currently active.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -460,19 +420,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_active() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether dropdowns should have a tearoff menu item.
+  /** Whether dropdowns should have a tearoff menu item.
    *
    * 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_add_tearoffs() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether dropdowns should have a tearoff menu item.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -480,19 +436,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_add_tearoffs() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the combo box draws a frame around the child.
+  /** Whether the combo box draws a frame around the child.
    *
    * 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_has_frame() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the combo box draws a frame around the child.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -500,19 +452,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_frame() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the combo box grabs focus when it is clicked with the mouse.
+  /** Whether the combo box grabs focus when it is clicked with the mouse.
    *
    * 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_focus_on_click() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the combo box grabs focus when it is clicked with the mouse.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -520,39 +468,7 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_focus_on_click() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A title that may be displayed by the window manager when the popup is torn-off.
-   *
-   * 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_tearoff_title() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** A title that may be displayed by the window manager when the popup is torn-off.
-   *
-   * 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_tearoff_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  /** The changed signal gets emitted when the active
-   * item is changed. This can be due to the user selecting
-   * a different item from the list, or due to a 
-   * call to set_active_iter().
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_changed();
                                              
@@ -571,8 +487,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ComboBox* wrap(GtkComboBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_COMBOBOX_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentry.cc b/libs/gtkmm2/gtk/gtkmm/comboboxentry.cc
index 0b850de778..90a0bf6b39 100644
--- a/libs/gtkmm2/gtk/gtkmm/comboboxentry.cc
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentry.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/comboboxentry.h>
 #include <gtkmm/private/comboboxentry_p.h>
 
@@ -93,19 +92,8 @@ void ComboBoxEntry_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ComboBoxEntry_Class::wrap_new(GObject* o)
 {
@@ -169,12 +157,12 @@ ComboBoxEntry::ComboBoxEntry(const Glib::RefPtr<TreeModel>& model, int text_colu
 
 void ComboBoxEntry::set_text_column(const TreeModelColumnBase& text_column) const
 {
-gtk_combo_box_entry_set_text_column(const_cast<GtkComboBoxEntry*>(gobj()), (text_column).index()); 
+  gtk_combo_box_entry_set_text_column(const_cast<GtkComboBoxEntry*>(gobj()), (text_column).index());
 }
 
 void ComboBoxEntry::set_text_column(int text_column) const
 {
-gtk_combo_box_entry_set_text_column(const_cast<GtkComboBoxEntry*>(gobj()), text_column); 
+  gtk_combo_box_entry_set_text_column(const_cast<GtkComboBoxEntry*>(gobj()), text_column);
 }
 
 int ComboBoxEntry::get_text_column() const
@@ -183,13 +171,6 @@ int ComboBoxEntry::get_text_column() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentry.h b/libs/gtkmm2/gtk/gtkmm/comboboxentry.h
index 72d8d8ec73..dce4c67019 100644
--- a/libs/gtkmm2/gtk/gtkmm/comboboxentry.h
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentry.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_COMBOBOXENTRY_H
 #define _GTKMM_COMBOBOXENTRY_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -99,17 +98,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -140,7 +133,7 @@ public:
   /** Sets the model column which @a entry_box  should use to get strings from
    * to be @a text_column .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    * @param text_column A column in @a model  to get the strings from.
    */
   void set_text_column(const TreeModelColumnBase& text_column) const;   
@@ -148,7 +141,7 @@ public:
   /** Sets the model column which @a entry_box  should use to get strings from
    * to be @a text_column .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    * @param text_column A column in @a model  to get the strings from.
    */
   void set_text_column(int text_column) const; 
@@ -156,17 +149,17 @@ public:
   /** Returns the column which @a entry_box  is using to get the strings from.
    * @return A column in the data source model of @a entry_box .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_text_column() const; 
 
   //The child is always an entry:
 
-  /** @see Bin::get_child().
+  /** See Bin::get_entry().
    */
   Entry* get_entry();
 
-  /** @see Bin::get_child().
+  /** See Bin::get_entry().
    */
   const Entry* get_entry() const;                                      
 
@@ -185,8 +178,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ComboBoxEntry* wrap(GtkComboBoxEntry* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_COMBOBOXENTRY_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.cc b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.cc
index b4eda9cb3c..d74c01ae72 100644
--- a/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.cc
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.cc
@@ -81,44 +81,16 @@ void ComboBoxEntryText::prepend_text(const Glib::ustring& text)
   }
 }
 
-//deprecated.
 void ComboBoxEntryText::clear()
 {
-  clear_items();
-}
-
-void ComboBoxEntryText::clear_items()
-{
   //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
   Glib::RefPtr<Gtk::TreeModel> model = get_model();
   Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
-
+  
   if(list_model)  
     list_model->clear();
 }
 
-void ComboBoxEntryText::remove_text(const Glib::ustring& text)
-{
-  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
-  Glib::RefPtr<Gtk::TreeModel> model = get_model();
-  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
-
-  //Look for the row with this text, and remove it:
-  if(list_model)
-  {
-    for(Gtk::TreeModel::iterator iter = list_model->children().begin(); iter != list_model->children().end(); ++iter)
-    {
-      const Glib::ustring& this_text = (*iter)[m_text_columns.m_column];
-
-      if(this_text == text)
-      {
-        list_model->erase(iter);
-        return; //success
-      }
-    }
-  }
-}
-
 Glib::ustring ComboBoxEntryText::get_active_text() const
 {
   Glib::ustring result;
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.h b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.h
index 2ca020a3c6..fe9e6bbdf8 100644
--- a/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.h
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxentrytext.h
@@ -53,39 +53,18 @@ protected:
 
 public:
   ComboBoxEntryText();
-
-  /** Add an item to the end of the drop-down list.
-   * @param text The text for the item.
-   */
+  
   void append_text(const Glib::ustring& text);
-
+  
   void insert_text(int position, const Glib::ustring& text);
-
-  /** Add an item to the beginning of the drop-down list.
-   * @param text The text for the item.
-   */
+  
   void prepend_text(const Glib::ustring& text);
 
-  //@deprecated Use get_entry()->get_text() to get the actual entered text.
   Glib::ustring get_active_text() const;
-
-  //@deprecated Use get_entry()->set_text() to set the actual entered text.
   void set_active_text(const Glib::ustring& text);
 
-  //There is a clear() method in the CellLayout base class, so this would cause confusion.
-  //TODO: Remove this when we can break API.
-  /// @deprecated See clear_items(). Since 2.8.
   void clear();
 
-  /** Remove all items from the drop-down menu.
-   */
-  void clear_items();
-
-  /** Remove the specified item if it is in the drop-down menu.
-   * @text The text of the item that should be removed.
-   */
-  void remove_text(const Glib::ustring& text);
-
 protected:
 
   //Tree model columns:
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxtext.cc b/libs/gtkmm2/gtk/gtkmm/comboboxtext.cc
index b5f1f73f7e..a9c8d20d5f 100644
--- a/libs/gtkmm2/gtk/gtkmm/comboboxtext.cc
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxtext.cc
@@ -99,14 +99,8 @@ Glib::ustring ComboBoxText::get_active_text() const
   return result;
 }
 
-//deprecated.
 void ComboBoxText::clear()
 {
-  clear_items();
-}
-
-void ComboBoxText::clear_items()
-{
   //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
   Glib::RefPtr<Gtk::TreeModel> model = get_model();
   Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
@@ -115,28 +109,6 @@ void ComboBoxText::clear_items()
     list_model->clear();
 }
 
-void ComboBoxText::remove_text(const Glib::ustring& text)
-{
-  //Ideally, we would just store the ListStore as a member variable, but we forgot to do that and not it would break the ABI.
-  Glib::RefPtr<Gtk::TreeModel> model = get_model();
-  Glib::RefPtr<Gtk::ListStore> list_model = Glib::RefPtr<ListStore>::cast_dynamic(model);
-
-  //Look for the row with this text, and remove it:
-  if(list_model)
-  {
-    for(Gtk::TreeModel::iterator iter = list_model->children().begin(); iter != list_model->children().end(); ++iter)
-    {
-      const Glib::ustring& this_text = (*iter)[m_text_columns.m_column];
-
-      if(this_text == text)
-      {
-        list_model->erase(iter);
-        return; //success
-      }
-    }
-  }
-}
-
 void ComboBoxText::set_active_text(const Glib::ustring& text)
 {
   //Look for the row with this text, and activate it:
diff --git a/libs/gtkmm2/gtk/gtkmm/comboboxtext.h b/libs/gtkmm2/gtk/gtkmm/comboboxtext.h
index cff1bc8bf4..22b87f5f00 100644
--- a/libs/gtkmm2/gtk/gtkmm/comboboxtext.h
+++ b/libs/gtkmm2/gtk/gtkmm/comboboxtext.h
@@ -56,43 +56,18 @@ protected:
 
 public:
   ComboBoxText();
-
-  /** Add an item to the end of the drop-down list.
-   * @param text The text for the item.
-   */
+  
   void append_text(const Glib::ustring& text);
-
+  
   void insert_text(int position, const Glib::ustring& text);
-
-  /** Add an item to the beginning of the drop-down list.
-   * @param text The text for the item.
-   */
+  
   void prepend_text(const Glib::ustring& text);
 
-  /** Get the currently-chosen item.
-   * @result The text of the active item.
-   */
   Glib::ustring get_active_text() const;
-
-  /** Set the currently-chosen item if it matches the specified text.
-   * @text The text of the item that should be selected.
-   */
   void set_active_text(const Glib::ustring& text);
 
-  //There is a clear() method in the CellLayout base class, so this would cause confusion.
-  //TODO: Remove this when we can break API.
-  /// @deprecated See clear_items(). Since 2.8.
   void clear();
 
-  /** Remove all items from the drop-down menu.
-   */
-  void clear_items();
-
-  /** Remove the specified item if it is in the drop-down menu.
-   * @text The text of the item that should be removed.
-   */
-  void remove_text(const Glib::ustring& text);
-
 protected:
 
   //Tree model columns:
diff --git a/libs/gtkmm2/gtk/gtkmm/container.cc b/libs/gtkmm2/gtk/gtkmm/container.cc
index 6c6d70caec..c3db4bd7ef 100644
--- a/libs/gtkmm2/gtk/gtkmm/container.cc
+++ b/libs/gtkmm2/gtk/gtkmm/container.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/container.h>
 #include <gtkmm/private/container_p.h>
 
@@ -31,74 +30,22 @@
 namespace
 {
 
-static void container_foreach_callback(GtkWidget* widget_gobj, void* data)
+
+void container_foreach_callback(GtkWidget* widget_gobj, void* data)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Gtk::Container::ForeachSlot& slot = *static_cast<Gtk::Container::ForeachSlot*>(data);
     Gtk::Widget *const widget = Glib::wrap(widget_gobj);
 
     g_return_if_fail(widget != 0);
 
     slot(*widget);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-
-//Copy of generated callback:
-static void Container_signal_remove_callback_normal(GtkContainer* self, GtkWidget* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,Widget* > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static void Container_signal_remove_callback(GtkContainer* self, GtkWidget* p0, void* data)
-{
-  //GTKMM_LIFECYCLE
-
-#ifdef GLIBMM_DEBUG_REFCOUNTING
-  g_warning("Container_signal_remove_callback()");
-#endif
-
-  //Don't call wrap() on a GTK+ instance whose gtkmm instance has been deleted - just call the original C callback.
-  const bool gtkmm_child_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
-
-  if(!gtkmm_child_already_deleted)
-  {
-    //Call the regular, generated callback:
-    Container_signal_remove_callback_normal(self, p0, data);
-  }
-  else
-  {
-    //Do nothing.
-  }
 }
 
 } // anonymous namespace
@@ -107,49 +54,7 @@ static void Container_signal_remove_callback(GtkContainer* self, GtkWidget* p0,
 namespace Gtk
 {
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-//Copy of generated callback:
-void Container_Class::remove_callback_normal(GtkContainer* self, GtkWidget* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_remove(Glib::wrap(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->remove)
-      (*base->remove)(self, p0);
-  }
-}
-
-//Custom hand-coded callback:
-void Container_Class::remove_callback(GtkContainer* self, GtkWidget* p0)
+void Container_Class::remove_callback_custom(GtkContainer* self, GtkWidget* p0)
 {
   //GTKMM_LIFECYCLE
 
@@ -159,12 +64,12 @@ void Container_Class::remove_callback(GtkContainer* self, GtkWidget* p0)
 #endif
   
   //Don't call wrap() on a GTK+ instance whose gtkmm instance has been deleted - just call the original C callback.
-  const bool gtkmm_child_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
+  bool gtkmm_child_already_deleted = Glib::_gobject_cppinstance_already_deleted((GObject*)p0);
 
   if(!gtkmm_child_already_deleted)
   {
     //Call the regular, generated callback:
-    Container_Class::remove_callback_normal(self, p0);
+    Container_Class::remove_callback(self, p0);
   }
   else
   {
@@ -177,7 +82,6 @@ void Container_Class::remove_callback(GtkContainer* self, GtkWidget* p0)
       (*base->remove)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 void Container::foreach(const Container::ForeachSlot& slot)
 {
@@ -238,7 +142,6 @@ void Container::remove(Widget& widget)
   gtk_container_remove(gobj(), widget.gobj());
 }
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 // static
 void Container_Class::destroy_callback(GtkObject* self)
 {
@@ -256,7 +159,6 @@ void Container_Class::destroy_callback(GtkObject* self)
   if(base->destroy)
     (*base->destroy)(self);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 } // namespace Gtk
 
@@ -264,8 +166,7 @@ void Container_Class::destroy_callback(GtkObject* self)
 namespace
 {
 
-
-static void Container_signal_add_callback(GtkContainer* self, GtkWidget* p0,void* data)
+void Container_signal_add_callback(GtkContainer* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -273,24 +174,20 @@ static void Container_signal_add_callback(GtkContainer* self, GtkWidget* p0,void
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Container_signal_add_info =
+const Glib::SignalProxyInfo Container_signal_add_info =
 {
   "add",
   (GCallback) &Container_signal_add_callback,
@@ -298,7 +195,28 @@ static const Glib::SignalProxyInfo Container_signal_add_info =
 };
 
 
-static const Glib::SignalProxyInfo Container_signal_remove_info =
+void Container_signal_remove_callback(GtkContainer* self, GtkWidget* p0,void* data)
+{
+  using namespace Gtk;
+  typedef sigc::slot< void,Widget* > 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)
+);
+    }
+    catch(...)
+    {
+      Glib::exception_handlers_invoke();
+    }
+  }
+}
+
+const Glib::SignalProxyInfo Container_signal_remove_info =
 {
   "remove",
   (GCallback) &Container_signal_remove_callback,
@@ -306,7 +224,7 @@ static const Glib::SignalProxyInfo Container_signal_remove_info =
 };
 
 
-static const Glib::SignalProxyInfo Container_signal_check_resize_info =
+const Glib::SignalProxyInfo Container_signal_check_resize_info =
 {
   "check_resize",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -314,7 +232,7 @@ static const Glib::SignalProxyInfo Container_signal_check_resize_info =
 };
 
 
-static void Container_signal_set_focus_child_callback(GtkContainer* self, GtkWidget* p0,void* data)
+void Container_signal_set_focus_child_callback(GtkContainer* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -322,31 +240,26 @@ static void Container_signal_set_focus_child_callback(GtkContainer* self, GtkWid
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Container_signal_set_focus_child_info =
+const Glib::SignalProxyInfo Container_signal_set_focus_child_info =
 {
   "set_focus_child",
   (GCallback) &Container_signal_set_focus_child_callback,
   (GCallback) &Container_signal_set_focus_child_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -391,24 +304,28 @@ void Container_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->child_type = &child_type_vfunc_callback;
   klass->forall = &forall_vfunc_callback;
   klass->composite_name = &composite_name_vfunc_callback;
   klass->set_child_property = &set_child_property_vfunc_callback;
   klass->get_child_property = &get_child_property_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->add = &add_callback;
   klass->remove = &remove_callback;
   klass->check_resize = &check_resize_callback;
   klass->set_focus_child = &set_focus_child_callback;
     reinterpret_cast<GtkObjectClass*>(klass)->destroy = &destroy_callback;
-  #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
+      klass->remove = &remove_callback_custom;
+
+    if(G_OBJECT_CLASS_TYPE(klass) == Gtk::Container::get_type())
+    { 
+      //Remove the parent class's (GtkContainer) remove callback - it just prints a warning.
+      //This prevents that warning when people derive directly from Gtk::Container.
+      BaseClassType *const base = static_cast<BaseClassType*>( g_type_class_peek_parent(klass) );
+      base->remove = 0;
+    }
+                
+  }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 GtkType Container_Class::child_type_vfunc_callback(GtkContainer* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -421,19 +338,15 @@ GtkType Container_Class::child_type_vfunc_callback(GtkContainer* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->child_type_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -449,6 +362,7 @@ GtkType Container_Class::child_type_vfunc_callback(GtkContainer* self)
   typedef GtkType RType;
   return RType();
 }
+
 void Container_Class::forall_vfunc_callback(GtkContainer* self, gboolean include_internals, GtkCallback callback, gpointer callback_data)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -461,19 +375,15 @@ void Container_Class::forall_vfunc_callback(GtkContainer* self, gboolean include
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->forall_vfunc(include_internals, callback, callback_data);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -486,6 +396,7 @@ void Container_Class::forall_vfunc_callback(GtkContainer* self, gboolean include
       (*base->forall)(self, include_internals, callback, callback_data);
   }
 }
+
 gchar* Container_Class::composite_name_vfunc_callback(GtkContainer* self, GtkWidget* child)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -498,19 +409,15 @@ gchar* Container_Class::composite_name_vfunc_callback(GtkContainer* self, GtkWid
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->composite_name_vfunc(child);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -526,6 +433,7 @@ gchar* Container_Class::composite_name_vfunc_callback(GtkContainer* self, GtkWid
   typedef gchar* RType;
   return RType();
 }
+
 void Container_Class::set_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -538,19 +446,15 @@ void Container_Class::set_child_property_vfunc_callback(GtkContainer* self, GtkW
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_child_property_vfunc(child, property_id, value, pspec);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -563,6 +467,7 @@ void Container_Class::set_child_property_vfunc_callback(GtkContainer* self, GtkW
       (*base->set_child_property)(self, child, property_id, value, pspec);
   }
 }
+
 void Container_Class::get_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -575,19 +480,15 @@ void Container_Class::get_child_property_vfunc_callback(GtkContainer* self, GtkW
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_child_property_vfunc(child, property_id, value, pspec);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -600,9 +501,8 @@ void Container_Class::get_child_property_vfunc_callback(GtkContainer* self, GtkW
       (*base->get_child_property)(self, child, property_id, value, pspec);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Container_Class::add_callback(GtkContainer* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -615,20 +515,16 @@ void Container_Class::add_callback(GtkContainer* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_add(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -641,6 +537,42 @@ void Container_Class::add_callback(GtkContainer* self, GtkWidget* p0)
       (*base->add)(self, p0);
   }
 }
+
+void Container_Class::remove_callback(GtkContainer* self, GtkWidget* 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_remove(Glib::wrap(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->remove)
+      (*base->remove)(self, p0);
+  }
+}
+
 void Container_Class::check_resize_callback(GtkContainer* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -653,19 +585,15 @@ void Container_Class::check_resize_callback(GtkContainer* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_check_resize();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -678,6 +606,7 @@ void Container_Class::check_resize_callback(GtkContainer* self)
       (*base->check_resize)(self);
   }
 }
+
 void Container_Class::set_focus_child_callback(GtkContainer* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -690,20 +619,16 @@ void Container_Class::set_focus_child_callback(GtkContainer* self, GtkWidget* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_focus_child(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -716,7 +641,6 @@ void Container_Class::set_focus_child_callback(GtkContainer* self, GtkWidget* p0
       (*base->set_focus_child)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Container_Class::wrap_new(GObject* o)
@@ -760,7 +684,7 @@ GType Container::get_base_type()
 
 void Container::set_border_width(guint border_width)
 {
-gtk_container_set_border_width(gobj(), border_width); 
+  gtk_container_set_border_width(gobj(), border_width);
 }
 
 guint Container::get_border_width() const
@@ -770,7 +694,7 @@ guint Container::get_border_width() const
 
 void Container::set_resize_mode(ResizeMode resize_mode)
 {
-gtk_container_set_resize_mode(gobj(), ((GtkResizeMode)(resize_mode))); 
+  gtk_container_set_resize_mode(gobj(), ((GtkResizeMode)(resize_mode)));
 }
 
 ResizeMode Container::get_resize_mode() const
@@ -780,7 +704,7 @@ ResizeMode Container::get_resize_mode() const
 
 void Container::check_resize()
 {
-gtk_container_check_resize(gobj()); 
+  gtk_container_check_resize(gobj());
 }
 
 Glib::ListHandle<Widget*> Container::get_children()
@@ -795,32 +719,32 @@ Glib::ListHandle<const Widget*> Container::get_children() const
 
 void Container::propagate_expose(Widget& child, GdkEventExpose* event)
 {
-gtk_container_propagate_expose(gobj(), (child).gobj(), event); 
+  gtk_container_propagate_expose(gobj(), (child).gobj(), event);
 }
 
 void Container::set_focus_chain(const Glib::ListHandle<Widget*>& focusable_widgets)
 {
-gtk_container_set_focus_chain(gobj(), focusable_widgets.data()); 
+  gtk_container_set_focus_chain(gobj(), focusable_widgets.data());
 }
 
 void Container::unset_focus_chain()
 {
-gtk_container_unset_focus_chain(gobj()); 
+  gtk_container_unset_focus_chain(gobj());
 }
 
 void Container::set_reallocate_redraws(bool needs_redraws)
 {
-gtk_container_set_reallocate_redraws(gobj(), static_cast<int>(needs_redraws)); 
+  gtk_container_set_reallocate_redraws(gobj(), static_cast<int>(needs_redraws));
 }
 
 void Container::set_focus_child(Widget& widget)
 {
-gtk_container_set_focus_child(gobj(), (widget).gobj()); 
+  gtk_container_set_focus_child(gobj(), (widget).gobj());
 }
 
 void Container::set_focus_vadjustment(Adjustment& adjustment)
 {
-gtk_container_set_focus_vadjustment(gobj(), (adjustment).gobj()); 
+  gtk_container_set_focus_vadjustment(gobj(), (adjustment).gobj());
 }
 
 Adjustment* Container::get_focus_vadjustment()
@@ -830,12 +754,12 @@ Adjustment* Container::get_focus_vadjustment()
 
 const Adjustment* Container::get_focus_vadjustment() const
 {
-  return const_cast<Container*>(this)->get_focus_vadjustment();
+  return Glib::wrap(gtk_container_get_focus_vadjustment(const_cast<GtkContainer*>(gobj())));
 }
 
 void Container::set_focus_hadjustment(Adjustment& adjustment)
 {
-gtk_container_set_focus_hadjustment(gobj(), (adjustment).gobj()); 
+  gtk_container_set_focus_hadjustment(gobj(), (adjustment).gobj());
 }
 
 Adjustment* Container::get_focus_hadjustment()
@@ -845,12 +769,12 @@ Adjustment* Container::get_focus_hadjustment()
 
 const Adjustment* Container::get_focus_hadjustment() const
 {
-  return const_cast<Container*>(this)->get_focus_hadjustment();
+  return Glib::wrap(gtk_container_get_focus_hadjustment(const_cast<GtkContainer*>(gobj())));
 }
 
 void Container::resize_children()
 {
-gtk_container_resize_children(gobj()); 
+  gtk_container_resize_children(gobj());
 }
 
 GType Container::child_type() const
@@ -871,62 +795,53 @@ Glib::SignalProxy1< void,Widget* > Container::signal_add()
   return Glib::SignalProxy1< void,Widget* >(this, &Container_signal_add_info);
 }
 
-
 Glib::SignalProxy1< void,Widget* > Container::signal_remove()
 {
   return Glib::SignalProxy1< void,Widget* >(this, &Container_signal_remove_info);
 }
 
-
 Glib::SignalProxy0< void > Container::signal_check_resize()
 {
   return Glib::SignalProxy0< void >(this, &Container_signal_check_resize_info);
 }
 
-
 Glib::SignalProxy1< void,Widget* > Container::signal_set_focus_child()
 {
   return Glib::SignalProxy1< void,Widget* >(this, &Container_signal_set_focus_child_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Container::property_border_width() 
 {
   return Glib::PropertyProxy<guint>(this, "border-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Container::property_border_width() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "border-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ResizeMode> Container::property_resize_mode() 
 {
   return Glib::PropertyProxy<ResizeMode>(this, "resize-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ResizeMode> Container::property_resize_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<ResizeMode>(this, "resize-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Widget*> Container::property_child() 
 {
   return Glib::PropertyProxy_WriteOnly<Widget*>(this, "child");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
+
+Glib::PropertyProxy_ReadOnly<Widget*> Container::property_child() const
+{
+  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "child");
+}
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Container::on_add(Widget* widget)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -936,6 +851,7 @@ void Gtk::Container::on_add(Widget* widget)
   if(base && base->add)
     (*base->add)(gobj(),(GtkWidget*)Glib::unwrap(widget));
 }
+
 void Gtk::Container::on_remove(Widget* widget)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -945,6 +861,7 @@ void Gtk::Container::on_remove(Widget* widget)
   if(base && base->remove)
     (*base->remove)(gobj(),(GtkWidget*)Glib::unwrap(widget));
 }
+
 void Gtk::Container::on_check_resize()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -954,6 +871,7 @@ void Gtk::Container::on_check_resize()
   if(base && base->check_resize)
     (*base->check_resize)(gobj());
 }
+
 void Gtk::Container::on_set_focus_child(Widget* widget)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -963,9 +881,8 @@ void Gtk::Container::on_set_focus_child(Widget* widget)
   if(base && base->set_focus_child)
     (*base->set_focus_child)(gobj(),(GtkWidget*)Glib::unwrap(widget));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 GtkType Gtk::Container::child_type_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -978,6 +895,7 @@ GtkType Gtk::Container::child_type_vfunc() const
   typedef GtkType RType;
   return RType();
 }
+
 void Gtk::Container::forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -987,6 +905,7 @@ void Gtk::Container::forall_vfunc(gboolean include_internals, GtkCallback callba
   if(base && base->forall)
     (*base->forall)(gobj(),include_internals,callback,callback_data);
 }
+
 char* Gtk::Container::composite_name_vfunc(GtkWidget* child) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -999,6 +918,7 @@ char* Gtk::Container::composite_name_vfunc(GtkWidget* child)
   typedef char* RType;
   return RType();
 }
+
 void Gtk::Container::set_child_property_vfunc(GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1008,6 +928,7 @@ void Gtk::Container::set_child_property_vfunc(GtkWidget* child, guint property_i
   if(base && base->set_child_property)
     (*base->set_child_property)(gobj(),child,property_id,value,pspec);
 }
+
 void Gtk::Container::get_child_property_vfunc(GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1017,7 +938,6 @@ void Gtk::Container::get_child_property_vfunc(GtkWidget* child, guint property_i
   if(base && base->get_child_property)
     (*base->get_child_property)(const_cast<GtkContainer*>(gobj()),child,property_id,value,pspec);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/container.h b/libs/gtkmm2/gtk/gtkmm/container.h
index a3b04aaa08..a555229bbf 100644
--- a/libs/gtkmm2/gtk/gtkmm/container.h
+++ b/libs/gtkmm2/gtk/gtkmm/container.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CONTAINER_H
 #define _GTKMM_CONTAINER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -110,21 +109,15 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_add(Widget* widget);
   virtual void on_remove(Widget* widget);
   virtual void on_check_resize();
   virtual void on_set_focus_child(Widget* widget);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -161,9 +154,14 @@ public:
   
 
   /** Removes @a widget  from @a container . @a widget  must be inside @a container .
-   * If @a widget  is managed with Gtk::manage(), and you don't want to use @a widget 
-   * again then you should delete @a widget , because there will no longer be any parent 
-   * container to delete it automatically.
+   * Note that @a container  will own a reference to @a widget , and that this
+   * may be the last reference held; so removing a widget from its
+   * container can destroy that widget. If you want to use @a widget 
+   * again, you need to add a reference to it while it's not inside
+   * a container, using Glib::object_ref(). If you don't want to use @a widget 
+   * again it's usually more efficient to simply destroy it directly
+   * using Gtk::Widget::destroy() since this will remove it from the
+   * container and help break any circular reference count cycles.
    * @param widget A current child of @a container .
    */
 
@@ -213,13 +211,13 @@ public:
   //_WRAP_METHOD(void foreach_full_(GtkCallback callback,GtkCallbackMarshal marshal, gpointer data,GtkDestroyNotify notify),gtk_container_foreach_full)
 
   
-  /** Returns the container's non-internal children. See
+  /** Returns the the container's non-internal children. See
    * forall() for details on what constitutes an "internal" child.
    * @return A newly-allocated list of the container's non-internal children.
    */
   Glib::ListHandle<Widget*> get_children();
   
-  /** Returns the container's non-internal children. See
+  /** Returns the the container's non-internal children. See
    * forall() for details on what constitutes an "internal" child.
    * @return A newly-allocated list of the container's non-internal children.
    */
@@ -357,38 +355,15 @@ public:
   // Ignore functions such as gtk_container_class_install_child_property(),  which I think are for themes, like the GtkWidget style properties.
   
 
-/**
-   * @par Prototype:
-   * <tt>void %add(Widget* widget)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget* > signal_add();
 
-
-  //We use the optional custom_c_callback parameter with _WRAP_SIGNAL() here,
-  //so that we can write special code to check for deleted child widget parameters:
   
-/**
-   * @par Prototype:
-   * <tt>void %remove(Widget* widget)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget* > signal_remove();
 
-
-/**
-   * @par Prototype:
-   * <tt>void %check_resize()</tt>
-   */
-
+  
   Glib::SignalProxy0< void > signal_check_resize();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %set_focus_child(Widget* widget)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget* > signal_set_focus_child();
 
 
@@ -397,39 +372,21 @@ public:
 protected:
   Container();
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual GtkType child_type_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual GtkType child_type_vfunc() const;
+    virtual void forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data);
   //TODO: What is this?
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual char* composite_name_vfunc(GtkWidget* child);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_child_property_vfunc(GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual char* composite_name_vfunc(GtkWidget* child);
+    virtual void set_child_property_vfunc(GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec);
+    virtual void get_child_property_vfunc(GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec) const;
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_child_property_vfunc(GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The width of the empty border outside the containers children.
+  /** The width of the empty border outside the containers children.
    *
    * 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_border_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The width of the empty border outside the containers children.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -437,19 +394,15 @@ protected:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_border_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Specify how resize events are handled.
+  /** Specify how resize events are handled.
    *
    * 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<ResizeMode> property_resize_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Specify how resize events are handled.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -457,17 +410,22 @@ protected:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ResizeMode> property_resize_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Can be used to add a new child to the container.
+  /** Can be used to add a new child to the container.
    *
    * 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<Widget*> property_child() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+
+/** Can be used to add a new child to the container.
+   *
+   * 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<Widget*> property_child() const;
 
 
 };
@@ -483,8 +441,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Container* wrap(GtkContainer* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CONTAINER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/curve.cc b/libs/gtkmm2/gtk/gtkmm/curve.cc
index 9cd9cc345e..ed6b949ea3 100644
--- a/libs/gtkmm2/gtk/gtkmm/curve.cc
+++ b/libs/gtkmm2/gtk/gtkmm/curve.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/curve.h>
 #include <gtkmm/private/curve_p.h>
 
@@ -51,15 +50,13 @@ void Curve::set_vector(const Glib::ArrayHandle<float>& array)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Curve_signal_curve_type_changed_info =
+const Glib::SignalProxyInfo Curve_signal_curve_type_changed_info =
 {
   "curve_type_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -104,18 +101,10 @@ void Curve_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->curve_type_changed = &curve_type_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Curve_Class::curve_type_changed_callback(GtkCurve* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -128,19 +117,15 @@ void Curve_Class::curve_type_changed_callback(GtkCurve* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_curve_type_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -153,7 +138,6 @@ void Curve_Class::curve_type_changed_callback(GtkCurve* self)
       (*base->curve_type_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Curve_Class::wrap_new(GObject* o)
@@ -204,27 +188,27 @@ Curve::Curve()
 
 void Curve::reset()
 {
-gtk_curve_reset(gobj()); 
+  gtk_curve_reset(gobj());
 }
 
 void Curve::set_gamma(float gamma)
 {
-gtk_curve_set_gamma(gobj(), gamma); 
+  gtk_curve_set_gamma(gobj(), gamma);
 }
 
 void Curve::set_range(float min_x, float max_x, float min_y, float max_y)
 {
-gtk_curve_set_range(gobj(), min_x, max_x, min_y, max_y); 
+  gtk_curve_set_range(gobj(), min_x, max_x, min_y, max_y);
 }
 
 void Curve::get_vector(int veclen, float* data) const
 {
-gtk_curve_get_vector(const_cast<GtkCurve*>(gobj()), veclen, data); 
+  gtk_curve_get_vector(const_cast<GtkCurve*>(gobj()), veclen, data);
 }
 
 void Curve::set_curve_type(CurveType type)
 {
-gtk_curve_set_curve_type(gobj(), ((GtkCurveType)(type))); 
+  gtk_curve_set_curve_type(gobj(), ((GtkCurveType)(type)));
 }
 
 
@@ -234,78 +218,57 @@ Glib::SignalProxy0< void > Curve::signal_curve_type_changed()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<CurveType> Curve::property_curve_type() 
 {
   return Glib::PropertyProxy<CurveType>(this, "curve-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<CurveType> Curve::property_curve_type() const
 {
   return Glib::PropertyProxy_ReadOnly<CurveType>(this, "curve-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Curve::property_min_x() 
 {
   return Glib::PropertyProxy<float>(this, "min-x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Curve::property_min_x() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "min-x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Curve::property_max_x() 
 {
   return Glib::PropertyProxy<float>(this, "max-x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Curve::property_max_x() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "max-x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Curve::property_min_y() 
 {
   return Glib::PropertyProxy<float>(this, "min-y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Curve::property_min_y() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "min-y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Curve::property_max_y() 
 {
   return Glib::PropertyProxy<float>(this, "max-y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Curve::property_max_y() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "max-y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Curve::on_curve_type_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -315,10 +278,6 @@ void Gtk::Curve::on_curve_type_changed()
   if(base && base->curve_type_changed)
     (*base->curve_type_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -365,19 +324,8 @@ void GammaCurve_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* GammaCurve_Class::wrap_new(GObject* o)
 {
@@ -425,13 +373,6 @@ GammaCurve::GammaCurve()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/curve.h b/libs/gtkmm2/gtk/gtkmm/curve.h
index 9ccfcc7e90..eaddc1116b 100644
--- a/libs/gtkmm2/gtk/gtkmm/curve.h
+++ b/libs/gtkmm2/gtk/gtkmm/curve.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_CURVE_H
 #define _GTKMM_CURVE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -99,18 +98,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_curve_type_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -136,25 +129,17 @@ public:
   void set_curve_type(CurveType type);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %curve_type_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_curve_type_changed();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is this curve linear
+  /** Is this curve linear
    *
    * 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<CurveType> property_curve_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Is this curve linear
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -162,19 +147,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<CurveType> property_curve_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Minimum possible value for X.
+  /** Minimum possible value for 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<float> property_min_x() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Minimum possible value for X.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -182,19 +163,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_min_x() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Maximum possible X value.
+  /** Maximum possible X value.
    *
    * 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<float> property_max_x() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Maximum possible X value.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -202,19 +179,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_max_x() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Minimum possible value for Y.
+  /** Minimum possible value for 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<float> property_min_y() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Minimum possible value for Y.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -222,19 +195,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_min_y() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Maximum possible value for Y.
+  /** Maximum possible value for 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<float> property_max_y() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Maximum possible value for Y.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -242,7 +211,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_max_y() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -295,17 +263,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -327,9 +289,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Curve* wrap(GtkCurve* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::GammaCurve
@@ -338,8 +298,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::GammaCurve* wrap(GtkGammaCurve* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_CURVE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/dialog.cc b/libs/gtkmm2/gtk/gtkmm/dialog.cc
index 803a6b149d..b55b84f645 100644
--- a/libs/gtkmm2/gtk/gtkmm/dialog.cc
+++ b/libs/gtkmm2/gtk/gtkmm/dialog.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/dialog.h>
 #include <gtkmm/private/dialog_p.h>
 
@@ -64,8 +63,7 @@ void Dialog::set_alternative_button_order_from_array(const Glib::ArrayHandle<int
 namespace
 {
 
-
-static void Dialog_signal_response_callback(GtkDialog* self, gint p0,void* data)
+void Dialog_signal_response_callback(GtkDialog* self, gint p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,int > SlotType;
@@ -73,31 +71,26 @@ static void Dialog_signal_response_callback(GtkDialog* self, gint p0,void* data)
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Dialog_signal_response_info =
+const Glib::SignalProxyInfo Dialog_signal_response_info =
 {
   "response",
   (GCallback) &Dialog_signal_response_callback,
   (GCallback) &Dialog_signal_response_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -148,18 +141,10 @@ void Dialog_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->response = &response_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Dialog_Class::response_callback(GtkDialog* self, gint p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -172,20 +157,16 @@ void Dialog_Class::response_callback(GtkDialog* self, gint p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_response(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -198,7 +179,6 @@ void Dialog_Class::response_callback(GtkDialog* self, gint p0)
       (*base->response)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Dialog_Class::wrap_new(GObject* o)
@@ -249,7 +229,7 @@ Dialog::Dialog()
 
 void Dialog::add_action_widget(Widget& child, int response_id)
 {
-gtk_dialog_add_action_widget(gobj(), (child).gobj(), response_id); 
+  gtk_dialog_add_action_widget(gobj(), (child).gobj(), response_id);
 }
 
 Button* Dialog::add_button(const Glib::ustring& button_text, int response_id)
@@ -264,22 +244,17 @@ Button* Dialog::add_button(const Gtk::StockID& stock_id, int response_id)
 
 void Dialog::set_response_sensitive(int response_id, bool setting)
 {
-gtk_dialog_set_response_sensitive(gobj(), response_id, static_cast<int>(setting)); 
+  gtk_dialog_set_response_sensitive(gobj(), response_id, static_cast<int>(setting));
 }
 
 void Dialog::set_default_response(int response_id)
 {
-gtk_dialog_set_default_response(gobj(), response_id); 
-}
-
-int Dialog::get_response_for_widget(const Gtk::Widget& widget) const
-{
-  return gtk_dialog_get_response_for_widget(const_cast<GtkDialog*>(gobj()), const_cast<GtkWidget*>(widget.gobj()));
+  gtk_dialog_set_default_response(gobj(), response_id);
 }
 
 void Dialog::set_has_separator(bool setting)
 {
-gtk_dialog_set_has_separator(gobj(), static_cast<int>(setting)); 
+  gtk_dialog_set_has_separator(gobj(), static_cast<int>(setting));
 }
 
 bool Dialog::get_has_separator() const
@@ -292,10 +267,9 @@ bool Dialog::alternative_button_order(const Glib::RefPtr<const Gdk::Screen>& scr
   return gtk_alternative_dialog_button_order(const_cast<GdkScreen*>(Glib::unwrap<Gdk::Screen>(screen)));
 }
 
-
 void Dialog::response(int response_id)
 {
-gtk_dialog_response(gobj(), response_id); 
+  gtk_dialog_response(gobj(), response_id);
 }
 
 int Dialog::run()
@@ -303,7 +277,7 @@ int Dialog::run()
   return gtk_dialog_run(gobj());
 }
 
- VBox* Dialog::get_vbox()
+VBox* Dialog::get_vbox()
 {
   return Glib::wrap((GtkVBox*)(gobj()->vbox));
 }
@@ -312,8 +286,8 @@ const VBox* Dialog::get_vbox() const
 {
   return Glib::wrap((GtkVBox*)(gobj()->vbox));
 }
- 
- HButtonBox* Dialog::get_action_area()
+
+HButtonBox* Dialog::get_action_area()
 {
   return Glib::wrap((GtkHButtonBox*)(gobj()->action_area));
 }
@@ -322,7 +296,7 @@ const HButtonBox* Dialog::get_action_area() const
 {
   return Glib::wrap((GtkHButtonBox*)(gobj()->action_area));
 }
- 
+
 
 Glib::SignalProxy1< void,int > Dialog::signal_response()
 {
@@ -330,22 +304,17 @@ Glib::SignalProxy1< void,int > Dialog::signal_response()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Dialog::property_has_separator() 
 {
   return Glib::PropertyProxy<bool>(this, "has-separator");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Dialog::property_has_separator() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-separator");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Dialog::on_response(int response_id)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -355,10 +324,6 @@ void Gtk::Dialog::on_response(int response_id)
   if(base && base->response)
     (*base->response)(gobj(),response_id);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/dialog.h b/libs/gtkmm2/gtk/gtkmm/dialog.h
index d019795eb6..2b4ae3f461 100644
--- a/libs/gtkmm2/gtk/gtkmm/dialog.h
+++ b/libs/gtkmm2/gtk/gtkmm/dialog.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_DIALOG_H
 #define _GTKMM_DIALOG_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -163,18 +162,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_response(int response_id);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -234,16 +227,6 @@ public:
    */
   void set_default_response(int response_id);
   
-  /** Gets the response id of a widget in the action area
-   * of a dialog.
-   * @param widget A widget in the action area of @a dialog .
-   * @return The response id of @a widget , or Gtk::RESPONSE_NONE
-   * if @a widget  doesn't have a response id set.
-   * 
-   * @newin2p8.
-   */
-  int get_response_for_widget(const Gtk::Widget& widget) const;
-  
   /** Sets whether the dialog has a separator above the buttons.
    * <tt>true</tt> by default.
    * @param setting <tt>true</tt> to have a separator.
@@ -254,7 +237,7 @@ public:
    * @return <tt>true</tt> if the dialog has a separator.
    */
   bool get_has_separator() const;
-
+  
   
   /** Returns <tt>true</tt> if dialogs are expected to use an alternative
    * button order on the screen @a screen . See 
@@ -268,27 +251,11 @@ public:
    * @param screen A Gdk::Screen, or <tt>0</tt> to use the default screen.
    * @return Whether the alternative button order should be used
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   static bool alternative_button_order(const Glib::RefPtr<const Gdk::Screen>& screen);
-
-  /** Sets an alternative button order. If the gtk-alternative-button-order 
-   * setting is set to true, the dialog buttons are reordered according to 
-   * the order of the response ids in @a new_order.
-   *
-   * By default, GTK+ dialogs use the button order advocated by the Gnome 
-   * <ulink url="http://developer.gnome.org/projects/gup/hig/2.0/">Human 
-   * Interface Guidelines</ulink> with the affirmative button at the far 
-   * right, and the cancel button left of it. But the builtin GTK+ dialogs
-   * and #GtkMessageDialog<!-- -->s do provide an alternative button order,
-   * which is more suitable on some platforms, e.g. Windows.
-   *
-   * Use this function after adding all the buttons to your dialog
-   *
-   * @param new_order an array of response ids of the dialog's buttons.
-   * 
-   * @newinp26
-   */
+  	
+  //TODO: Document this:   
   void set_alternative_button_order_from_array(const Glib::ArrayHandle<int>& new_order);
   
 
@@ -332,22 +299,19 @@ public:
    */
   int run();
 
-   VBox* get_vbox();
+  VBox* get_vbox();
   const VBox* get_vbox() const;
-    HButtonBox* get_action_area();
+  HButtonBox* get_action_area();
   const HButtonBox* get_action_area() const;
- 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The dialog has a separator bar above its buttons.
+
+  /** The dialog has a separator bar above its buttons.
    *
    * 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_has_separator() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The dialog has a separator bar above its buttons.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -355,14 +319,8 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_separator() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-/**
-   * @par Prototype:
-   * <tt>void %response(int response_id)</tt>
-   */
-
   Glib::SignalProxy1< void,int > signal_response();
 
 
@@ -383,8 +341,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Dialog* wrap(GtkDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_DIALOG_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/drawingarea.cc b/libs/gtkmm2/gtk/gtkmm/drawingarea.cc
index 20796b368c..53c90ec888 100644
--- a/libs/gtkmm2/gtk/gtkmm/drawingarea.cc
+++ b/libs/gtkmm2/gtk/gtkmm/drawingarea.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/drawingarea.h>
 #include <gtkmm/private/drawingarea_p.h>
 
@@ -75,19 +74,8 @@ void DrawingArea_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* DrawingArea_Class::wrap_new(GObject* o)
 {
@@ -136,13 +124,6 @@ DrawingArea::DrawingArea()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/drawingarea.h b/libs/gtkmm2/gtk/gtkmm/drawingarea.h
index 0d0529c3a3..3d3774deb6 100644
--- a/libs/gtkmm2/gtk/gtkmm/drawingarea.h
+++ b/libs/gtkmm2/gtk/gtkmm/drawingarea.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_DRAWINGAREA_H
 #define _GTKMM_DRAWINGAREA_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -89,17 +88,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -122,8 +115,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::DrawingArea* wrap(GtkDrawingArea* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_DRAWINGAREA_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/editable.cc b/libs/gtkmm2/gtk/gtkmm/editable.cc
index 4f02024475..9109009a2f 100644
--- a/libs/gtkmm2/gtk/gtkmm/editable.cc
+++ b/libs/gtkmm2/gtk/gtkmm/editable.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/editable.h>
 #include <gtkmm/private/editable_p.h>
 
@@ -30,8 +29,7 @@
 namespace
 {
 
-
-static void Editable_signal_insert_text_callback(GtkEditable* self, const gchar* text,gint length,gint* position,void* data)
+void Editable_signal_insert_text_callback(GtkEditable* self, const gchar* text,gint length,gint* position,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::ustring&,int* > SlotType;
@@ -39,23 +37,19 @@ static void Editable_signal_insert_text_callback(GtkEditable* self, const gchar*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(      Glib::ustring(text, text + length), position);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Editable_signal_insert_text_info =
+const Glib::SignalProxyInfo Editable_signal_insert_text_info =
 {
   "insert_text",
   (GCallback) &Editable_signal_insert_text_callback,
@@ -63,7 +57,7 @@ static const Glib::SignalProxyInfo Editable_signal_insert_text_info =
 };
 
 
-static void Editable_signal_delete_text_callback(GtkEditable* self, gint start_pos,gint end_pos,void* data)
+void Editable_signal_delete_text_callback(GtkEditable* self, gint start_pos,gint end_pos,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,int,int > SlotType;
@@ -71,25 +65,21 @@ static void Editable_signal_delete_text_callback(GtkEditable* self, gint start_p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(start_pos
 , end_pos
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Editable_signal_delete_text_info =
+const Glib::SignalProxyInfo Editable_signal_delete_text_info =
 {
   "delete_text",
   (GCallback) &Editable_signal_delete_text_callback,
@@ -97,14 +87,13 @@ static const Glib::SignalProxyInfo Editable_signal_delete_text_info =
 };
 
 
-static const Glib::SignalProxyInfo Editable_signal_changed_info =
+const Glib::SignalProxyInfo Editable_signal_changed_info =
 {
   "changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -149,7 +138,6 @@ void Editable_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->do_insert_text = &do_insert_text_vfunc_callback;
   klass->do_delete_text = &do_delete_text_vfunc_callback;
   klass->get_chars = &get_chars_vfunc_callback;
@@ -157,16 +145,11 @@ void Editable_Class::iface_init_function(void* g_iface, void*)
   klass->get_selection_bounds = &get_selection_bounds_vfunc_callback;
   klass->set_position = &set_position_vfunc_callback;
   klass->get_position = &get_position_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->insert_text = &insert_text_callback;
   klass->delete_text = &delete_text_callback;
   klass->changed = &changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Editable_Class::do_insert_text_vfunc_callback(GtkEditable* self, const gchar* text, gint length, gint* position)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -179,19 +162,15 @@ void Editable_Class::do_insert_text_vfunc_callback(GtkEditable* self, const gcha
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->insert_text_vfunc(      Glib::ustring(text, text + length), *position);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -205,6 +184,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->do_insert_text)(      self, text, length, position);
   }
 }
+
 void Editable_Class::do_delete_text_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -217,21 +197,17 @@ void Editable_Class::do_delete_text_vfunc_callback(GtkEditable* self, gint start
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->delete_text_vfunc(start_pos
 , end_pos
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -245,6 +221,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->do_delete_text)(self, start_pos, end_pos);
   }
 }
+
 gchar* Editable_Class::get_chars_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -257,21 +234,17 @@ gchar* Editable_Class::get_chars_vfunc_callback(GtkEditable* self, gint start_po
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return g_strdup((obj->get_chars_vfunc(start_pos
 , end_pos
 )).c_str());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -288,6 +261,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gchar* RType;
   return RType();
 }
+
 void Editable_Class::set_selection_bounds_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -300,21 +274,17 @@ void Editable_Class::set_selection_bounds_vfunc_callback(GtkEditable* self, gint
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->select_region_vfunc(start_pos
 , end_pos
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -328,6 +298,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_selection_bounds)(self, start_pos, end_pos);
   }
 }
+
 gboolean Editable_Class::get_selection_bounds_vfunc_callback(GtkEditable* self, gint* start_pos, gint* end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -340,21 +311,17 @@ gboolean Editable_Class::get_selection_bounds_vfunc_callback(GtkEditable* self,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->get_selection_bounds_vfunc(*(start_pos)
 , *(end_pos)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -371,6 +338,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 void Editable_Class::set_position_vfunc_callback(GtkEditable* self, gint position)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -383,20 +351,16 @@ void Editable_Class::set_position_vfunc_callback(GtkEditable* self, gint positio
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_position_vfunc(position
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -410,6 +374,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_position)(self, position);
   }
 }
+
 gint Editable_Class::get_position_vfunc_callback(GtkEditable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -422,19 +387,15 @@ gint Editable_Class::get_position_vfunc_callback(GtkEditable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_position_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -451,9 +412,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Editable_Class::insert_text_callback(GtkEditable* self, const gchar* text, gint length, gint* position)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -466,19 +426,15 @@ void Editable_Class::insert_text_callback(GtkEditable* self, const gchar* text,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_insert_text(      Glib::ustring(text, text + length), position);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -492,6 +448,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->insert_text)(      self, text, length, position);
   }
 }
+
 void Editable_Class::delete_text_callback(GtkEditable* self, gint start_pos, gint end_pos)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -504,21 +461,17 @@ void Editable_Class::delete_text_callback(GtkEditable* self, gint start_pos, gin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_delete_text(start_pos
 , end_pos
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -532,6 +485,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->delete_text)(self, start_pos, end_pos);
   }
 }
+
 void Editable_Class::changed_callback(GtkEditable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -544,19 +498,15 @@ void Editable_Class::changed_callback(GtkEditable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -570,7 +520,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Editable_Class::wrap_new(GObject* object)
@@ -615,27 +564,27 @@ GType Editable::get_base_type()
 
 void Editable::cut_clipboard()
 {
-gtk_editable_cut_clipboard(gobj()); 
+  gtk_editable_cut_clipboard(gobj());
 }
 
 void Editable::copy_clipboard()
 {
-gtk_editable_copy_clipboard(gobj()); 
+  gtk_editable_copy_clipboard(gobj());
 }
 
 void Editable::paste_clipboard()
 {
-gtk_editable_paste_clipboard(gobj()); 
+  gtk_editable_paste_clipboard(gobj());
 }
 
 void Editable::delete_selection()
 {
-gtk_editable_delete_selection(gobj()); 
+  gtk_editable_delete_selection(gobj());
 }
 
 void Editable::set_editable(bool is_editable)
 {
-gtk_editable_set_editable(gobj(), static_cast<int>(is_editable)); 
+  gtk_editable_set_editable(gobj(), static_cast<int>(is_editable));
 }
 
 bool Editable::get_editable() const
@@ -645,12 +594,12 @@ bool Editable::get_editable() const
 
 void Editable::insert_text(const Glib::ustring& text, int length, int& position)
 {
-gtk_editable_insert_text(gobj(), text.c_str(), length, &position); 
+  gtk_editable_insert_text(gobj(), text.c_str(), length, &position);
 }
 
 void Editable::delete_text(int start_pos, int end_pos)
 {
-gtk_editable_delete_text(gobj(), start_pos, end_pos); 
+  gtk_editable_delete_text(gobj(), start_pos, end_pos);
 }
 
 Glib::ustring Editable::get_chars(int start_pos, int end_pos) const
@@ -660,7 +609,7 @@ Glib::ustring Editable::get_chars(int start_pos, int end_pos) const
 
 void Editable::select_region(int start_pos, int end_pos)
 {
-gtk_editable_select_region(gobj(), start_pos, end_pos); 
+  gtk_editable_select_region(gobj(), start_pos, end_pos);
 }
 
 bool Editable::get_selection_bounds(int& start_pos, int& end_pos) const
@@ -670,7 +619,7 @@ bool Editable::get_selection_bounds(int& start_pos, int& end_pos) const
 
 void Editable::set_position(int position)
 {
-gtk_editable_set_position(gobj(), position); 
+  gtk_editable_set_position(gobj(), position);
 }
 
 int Editable::get_position() const
@@ -684,20 +633,17 @@ Glib::SignalProxy2< void,const Glib::ustring&,int* > Editable::signal_insert_tex
   return Glib::SignalProxy2< void,const Glib::ustring&,int* >(this, &Editable_signal_insert_text_info);
 }
 
-
 Glib::SignalProxy2< void,int,int > Editable::signal_delete_text()
 {
   return Glib::SignalProxy2< void,int,int >(this, &Editable_signal_delete_text_info);
 }
 
-
 Glib::SignalProxy0< void > Editable::signal_changed()
 {
   return Glib::SignalProxy0< void >(this, &Editable_signal_changed_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Editable::on_insert_text(const Glib::ustring& text, int* position)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -708,6 +654,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->insert_text)
     (*base->insert_text)(gobj(),text.data(),text.bytes(),position);
 }
+
 void Gtk::Editable::on_delete_text(int start_pos, int end_pos)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -718,6 +665,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->delete_text)
     (*base->delete_text)(gobj(),start_pos,end_pos);
 }
+
 void Gtk::Editable::on_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -728,9 +676,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->changed)
     (*base->changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::Editable::insert_text_vfunc(const Glib::ustring& text, int& position) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -741,6 +688,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->do_insert_text)
     (*base->do_insert_text)(gobj(),text.data(),text.bytes(),&position);
 }
+
 void Gtk::Editable::delete_text_vfunc(int start_pos, int end_pos) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -751,6 +699,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->do_delete_text)
     (*base->do_delete_text)(gobj(),start_pos,end_pos);
 }
+
 Glib::ustring Gtk::Editable::get_chars_vfunc(int start_pos, int end_pos) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -764,6 +713,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef Glib::ustring RType;
   return RType();
 }
+
 void Gtk::Editable::select_region_vfunc(int start_pos, int end_pos) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -774,6 +724,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_selection_bounds)
     (*base->set_selection_bounds)(gobj(),start_pos,end_pos);
 }
+
 bool Gtk::Editable::get_selection_bounds_vfunc(int& start_pos, int& end_pos) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -787,6 +738,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 void Gtk::Editable::set_position_vfunc(int position) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -797,6 +749,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_position)
     (*base->set_position)(gobj(),position);
 }
+
 int Gtk::Editable::get_position_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -810,7 +763,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/editable.h b/libs/gtkmm2/gtk/gtkmm/editable.h
index edc79ed88b..89832dcba7 100644
--- a/libs/gtkmm2/gtk/gtkmm/editable.h
+++ b/libs/gtkmm2/gtk/gtkmm/editable.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_EDITABLE_H
 #define _GTKMM_EDITABLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -135,72 +134,40 @@ public:
   Glib::SignalProxy2< void,const Glib::ustring&,int* > signal_insert_text();
 
     
-/**
-   * @par Prototype:
-   * <tt>void %delete_text(int start_pos, int end_pos)</tt>
-   */
-
   Glib::SignalProxy2< void,int,int > signal_delete_text();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_changed();
 
 
 protected:
 
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void delete_text_vfunc(int start_pos, int end_pos);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void delete_text_vfunc(int start_pos, int end_pos);
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::ustring get_chars_vfunc(int start_pos, int end_pos) const;
-#endif //GLIBMM_VFUNCS_ENABLED
 
+    virtual Glib::ustring get_chars_vfunc(int start_pos, int end_pos) const;
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void select_region_vfunc(int start_pos, int end_pos);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool get_selection_bounds_vfunc(int& start_pos, int& end_pos) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_position_vfunc(int position);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_position_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void select_region_vfunc(int start_pos, int end_pos);
+    virtual bool get_selection_bounds_vfunc(int& start_pos, int& end_pos) const;
+    virtual void set_position_vfunc(int position);
+    virtual int get_position_vfunc() const;
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
 virtual void insert_text_vfunc(const Glib::ustring& text, int& position);
 
-#endif //GLIBMM_VFUNCS_ENABLED
-
+ 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_insert_text(const Glib::ustring& text, int* position);
   virtual void on_delete_text(int start_pos, int end_pos);
   virtual void on_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -219,6 +186,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_EDITABLE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/entry.cc b/libs/gtkmm2/gtk/gtkmm/entry.cc
index 9c10aecef8..6b08e95c3b 100644
--- a/libs/gtkmm2/gtk/gtkmm/entry.cc
+++ b/libs/gtkmm2/gtk/gtkmm/entry.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/entry.h>
 #include <gtkmm/private/entry_p.h>
 
@@ -32,8 +31,7 @@
 namespace
 {
 
-
-static void Entry_signal_populate_popup_callback(GtkEntry* self, GtkMenu* p0,void* data)
+void Entry_signal_populate_popup_callback(GtkEntry* self, GtkMenu* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Menu* > SlotType;
@@ -41,24 +39,20 @@ static void Entry_signal_populate_popup_callback(GtkEntry* self, GtkMenu* p0,voi
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Entry_signal_populate_popup_info =
+const Glib::SignalProxyInfo Entry_signal_populate_popup_info =
 {
   "populate_popup",
   (GCallback) &Entry_signal_populate_popup_callback,
@@ -66,7 +60,7 @@ static const Glib::SignalProxyInfo Entry_signal_populate_popup_info =
 };
 
 
-static void Entry_signal_insert_at_cursor_callback(GtkEntry* self, const gchar* p0,void* data)
+void Entry_signal_insert_at_cursor_callback(GtkEntry* self, const gchar* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::ustring& > SlotType;
@@ -74,24 +68,20 @@ static void Entry_signal_insert_at_cursor_callback(GtkEntry* self, const gchar*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Entry_signal_insert_at_cursor_info =
+const Glib::SignalProxyInfo Entry_signal_insert_at_cursor_info =
 {
   "insert_at_cursor",
   (GCallback) &Entry_signal_insert_at_cursor_callback,
@@ -99,14 +89,13 @@ static const Glib::SignalProxyInfo Entry_signal_insert_at_cursor_info =
 };
 
 
-static const Glib::SignalProxyInfo Entry_signal_activate_info =
+const Glib::SignalProxyInfo Entry_signal_activate_info =
 {
   "activate",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -153,20 +142,12 @@ void Entry_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->populate_popup = &populate_popup_callback;
   klass->insert_at_cursor = &insert_at_cursor_callback;
   klass->activate = &activate_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Entry_Class::populate_popup_callback(GtkEntry* self, GtkMenu* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -179,20 +160,16 @@ void Entry_Class::populate_popup_callback(GtkEntry* self, GtkMenu* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_populate_popup(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -205,6 +182,7 @@ void Entry_Class::populate_popup_callback(GtkEntry* self, GtkMenu* p0)
       (*base->populate_popup)(self, p0);
   }
 }
+
 void Entry_Class::insert_at_cursor_callback(GtkEntry* self, const gchar* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -217,20 +195,16 @@ void Entry_Class::insert_at_cursor_callback(GtkEntry* self, const gchar* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_insert_at_cursor(Glib::convert_const_gchar_ptr_to_ustring(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -243,6 +217,7 @@ void Entry_Class::insert_at_cursor_callback(GtkEntry* self, const gchar* p0)
       (*base->insert_at_cursor)(self, p0);
   }
 }
+
 void Entry_Class::activate_callback(GtkEntry* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -255,19 +230,15 @@ void Entry_Class::activate_callback(GtkEntry* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_activate();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -280,7 +251,6 @@ void Entry_Class::activate_callback(GtkEntry* self)
       (*base->activate)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Entry_Class::wrap_new(GObject* o)
@@ -331,7 +301,7 @@ Entry::Entry()
 
 void Entry::set_visibility(bool visible)
 {
-gtk_entry_set_visibility(gobj(), static_cast<int>(visible)); 
+  gtk_entry_set_visibility(gobj(), static_cast<int>(visible));
 }
 
 bool Entry::get_visibility() const
@@ -341,7 +311,7 @@ bool Entry::get_visibility() const
 
 void Entry::set_invisible_char(gunichar ch)
 {
-gtk_entry_set_invisible_char(gobj(), ch); 
+  gtk_entry_set_invisible_char(gobj(), ch);
 }
 
 gunichar Entry::get_invisible_char() const
@@ -351,7 +321,7 @@ gunichar Entry::get_invisible_char() const
 
 void Entry::set_has_frame(bool setting)
 {
-gtk_entry_set_has_frame(gobj(), static_cast<int>(setting)); 
+  gtk_entry_set_has_frame(gobj(), static_cast<int>(setting));
 }
 
 bool Entry::get_has_frame() const
@@ -359,19 +329,9 @@ bool Entry::get_has_frame() const
   return gtk_entry_get_has_frame(const_cast<GtkEntry*>(gobj()));
 }
 
-void Entry::set_inner_border(const Border& border)
-{
-gtk_entry_set_inner_border(gobj(), &(border)); 
-}
-
-Border Entry::get_inner_border() const
-{
-  return *(gtk_entry_get_inner_border(const_cast<GtkEntry*>(gobj())));
-}
-
 void Entry::set_max_length(int max)
 {
-gtk_entry_set_max_length(gobj(), max); 
+  gtk_entry_set_max_length(gobj(), max);
 }
 
 int Entry::get_max_length() const
@@ -381,7 +341,7 @@ int Entry::get_max_length() const
 
 void Entry::set_activates_default(bool setting)
 {
-gtk_entry_set_activates_default(gobj(), static_cast<int>(setting)); 
+  gtk_entry_set_activates_default(gobj(), static_cast<int>(setting));
 }
 
 gboolean Entry::get_activates_default() const
@@ -391,7 +351,7 @@ gboolean Entry::get_activates_default() const
 
 void Entry::set_width_chars(int n_chars)
 {
-gtk_entry_set_width_chars(gobj(), n_chars); 
+  gtk_entry_set_width_chars(gobj(), n_chars);
 }
 
 int Entry::get_width_chars() const
@@ -401,7 +361,7 @@ int Entry::get_width_chars() const
 
 void Entry::set_text(const Glib::ustring & text)
 {
-gtk_entry_set_text(gobj(), text.c_str()); 
+  gtk_entry_set_text(gobj(), text.c_str());
 }
 
 Glib::ustring Entry::get_text() const
@@ -413,20 +373,25 @@ Glib::RefPtr<Pango::Layout> Entry::get_layout()
 {
 
   Glib::RefPtr<Pango::Layout> retvalue = Glib::wrap(gtk_entry_get_layout(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Pango::Layout> Entry::get_layout() const
 {
-  return const_cast<Entry*>(this)->get_layout();
+
+  Glib::RefPtr<const Pango::Layout> retvalue = Glib::wrap(gtk_entry_get_layout(const_cast<GtkEntry*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Entry::get_layout_offsets(int& x, int& y)
 {
-gtk_entry_get_layout_offsets(gobj(), &x, &y); 
+  gtk_entry_get_layout_offsets(gobj(), &x, &y);
 }
 
 int Entry::layout_index_to_text_index(int layout_index) const
@@ -441,12 +406,12 @@ int Entry::text_index_to_layout_index(int text_index) const
 
 void Entry::set_alignment(float xalign)
 {
-gtk_entry_set_alignment(gobj(), xalign); 
+  gtk_entry_set_alignment(gobj(), xalign);
 }
 
 void Entry::set_alignment(AlignmentEnum xalign)
 {
-gtk_entry_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign)); 
+  gtk_entry_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign));
 }
 
 float Entry::get_alignment() const
@@ -456,211 +421,147 @@ float Entry::get_alignment() const
 
 void Entry::set_completion(const Glib::RefPtr<EntryCompletion>& completion)
 {
-gtk_entry_set_completion(gobj(), Glib::unwrap(completion)); 
+  gtk_entry_set_completion(gobj(), Glib::unwrap(completion));
 }
 
 Glib::RefPtr<EntryCompletion> Entry::get_completion()
 {
 
   Glib::RefPtr<EntryCompletion> retvalue = Glib::wrap(gtk_entry_get_completion(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const EntryCompletion> Entry::get_completion() const
 {
-  return const_cast<Entry*>(this)->get_completion();
+
+  Glib::RefPtr<const EntryCompletion> retvalue = Glib::wrap(gtk_entry_get_completion(const_cast<GtkEntry*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
- guint16 Entry::get_text_length() const
+guint16 Entry::get_text_length() const
 {
   return gobj()->text_length;
 }
- 
+
 
 Glib::SignalProxy1< void,Menu* > Entry::signal_populate_popup()
 {
   return Glib::SignalProxy1< void,Menu* >(this, &Entry_signal_populate_popup_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::ustring& > Entry::signal_insert_at_cursor()
 {
   return Glib::SignalProxy1< void,const Glib::ustring& >(this, &Entry_signal_insert_at_cursor_info);
 }
 
-
 Glib::SignalProxy0< void > Entry::signal_activate()
 {
   return Glib::SignalProxy0< void >(this, &Entry_signal_activate_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Entry::property_cursor_position() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "cursor-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Entry::property_selection_bound() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "selection-bound");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Entry::property_editable() 
 {
   return Glib::PropertyProxy<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Entry::property_editable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Entry::property_max_length() 
 {
   return Glib::PropertyProxy<int>(this, "max-length");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Entry::property_max_length() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "max-length");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Entry::property_visibility() 
 {
   return Glib::PropertyProxy<bool>(this, "visibility");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Entry::property_visibility() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visibility");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Entry::property_has_frame() 
 {
   return Glib::PropertyProxy<bool>(this, "has-frame");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Entry::property_has_frame() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-frame");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<gunichar> Entry::property_invisible_char() 
 {
   return Glib::PropertyProxy<gunichar>(this, "invisible-char");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<gunichar> Entry::property_invisible_char() const
 {
   return Glib::PropertyProxy_ReadOnly<gunichar>(this, "invisible-char");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Entry::property_activates_default() 
 {
   return Glib::PropertyProxy<bool>(this, "activates-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Entry::property_activates_default() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "activates-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Entry::property_width_chars() 
 {
   return Glib::PropertyProxy<int>(this, "width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Entry::property_width_chars() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Entry::property_scroll_offset() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "scroll-offset");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Entry::property_text() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Entry::property_text() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<float> Entry::property_xalign() 
-{
-  return Glib::PropertyProxy<float>(this, "xalign");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<float> Entry::property_xalign() const
-{
-  return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> Entry::property_truncate_multiline() 
-{
-  return Glib::PropertyProxy<bool>(this, "truncate-multiline");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> Entry::property_truncate_multiline() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "truncate-multiline");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Entry::on_populate_popup(Menu* menu)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -670,6 +571,7 @@ void Gtk::Entry::on_populate_popup(Menu* menu)
   if(base && base->populate_popup)
     (*base->populate_popup)(gobj(),(GtkMenu*)Glib::unwrap(menu));
 }
+
 void Gtk::Entry::on_insert_at_cursor(const Glib::ustring& str)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -679,6 +581,7 @@ void Gtk::Entry::on_insert_at_cursor(const Glib::ustring& str)
   if(base && base->insert_at_cursor)
     (*base->insert_at_cursor)(gobj(),str.c_str());
 }
+
 void Gtk::Entry::on_activate()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -688,10 +591,6 @@ void Gtk::Entry::on_activate()
   if(base && base->activate)
     (*base->activate)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/entry.h b/libs/gtkmm2/gtk/gtkmm/entry.h
index 4b2eb14177..d7b9a3fb3c 100644
--- a/libs/gtkmm2/gtk/gtkmm/entry.h
+++ b/libs/gtkmm2/gtk/gtkmm/entry.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ENTRY_H
 #define _GTKMM_ENTRY_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -45,9 +44,6 @@ namespace Gtk
 namespace Gtk
 {
 
-//TODO: This is used in Range too, so put it somewhere more appropriate:
-typedef GtkBorder Border;
-
 /** A single line text entry field.
  *
  * The Gtk::Entry widget is a single line text entry widget. A fairly large
@@ -104,20 +100,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_populate_popup(Menu* menu);
   virtual void on_insert_at_cursor(const Glib::ustring& str);
   virtual void on_activate();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -163,12 +153,6 @@ public:
    * @return Whether the entry has a beveled frame.
    */
   bool get_has_frame() const;
-
-  
-  void set_inner_border(const Border& border);
-  
-  Border get_inner_border() const;
-
   
   /** Sets the maximum allowed length of the contents of the widget. If
    * the current contents are longer than the given length, then they
@@ -231,8 +215,8 @@ public:
   /** Gets the Pango::Layout used to display the entry.
    * The layout is useful to e.g. convert text positions to
    * pixel positions, in combination with get_layout_offsets().
-   * The returned layout is owned by the entry and must not be 
-   * modified or freed by the caller.
+   * The returned layout is owned by the entry so need not be
+   * freed by the caller.
    * 
    * Keep in mind that the layout text may contain a preedit string, so
    * layout_index_to_text_index() and
@@ -245,8 +229,8 @@ public:
   /** Gets the Pango::Layout used to display the entry.
    * The layout is useful to e.g. convert text positions to
    * pixel positions, in combination with get_layout_offsets().
-   * The returned layout is owned by the entry and must not be 
-   * modified or freed by the caller.
+   * The returned layout is owned by the entry so need not be
+   * freed by the caller.
    * 
    * Keep in mind that the layout text may contain a preedit string, so
    * layout_index_to_text_index() and
@@ -303,7 +287,7 @@ public:
    * the horizontal positioning of the contents when the displayed
    * text is shorter than the width of the entry.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param xalign The horizontal alignment, from 0 (left) to 1 (right).
    * Reversed for RTL layouts.
    */
@@ -313,7 +297,7 @@ public:
    * the horizontal positioning of the contents when the displayed
    * text is shorter than the width of the entry.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param xalign The horizontal alignment, from 0 (left) to 1 (right).
    * Reversed for RTL layouts.
    */
@@ -322,7 +306,7 @@ public:
   /** Gets the value set by set_alignment().
    * @return The alignment
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   float get_alignment() const;
 
@@ -331,7 +315,7 @@ public:
    * All further configuration of the completion mechanism is done on
    *  @a completion  using the Gtk::EntryCompletion API.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param completion The Gtk::EntryCompletion.
    */
   void set_completion(const Glib::RefPtr<EntryCompletion>& completion);
@@ -339,83 +323,59 @@ public:
   /** Returns the auxiliary completion object currently in use by @a entry .
    * @return The auxiliary completion object currently in use by @a entry .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<EntryCompletion> get_completion();
   
   /** Returns the auxiliary completion object currently in use by @a entry .
    * @return The auxiliary completion object currently in use by @a entry .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const EntryCompletion> get_completion() const;
 
-   guint16 get_text_length() const;
- 
-  
-/**
-   * @par Prototype:
-   * <tt>void %populate_popup(Menu* menu)</tt>
-   */
+  guint16 get_text_length() const;
 
+  
   Glib::SignalProxy1< void,Menu* > signal_populate_popup();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %insert_at_cursor(const Glib::ustring& str)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::ustring& > signal_insert_at_cursor();
 
 
   //Key-binding signals:
-
-  //This is a keybinding signal, but it is allowed:
-  // http://mail.gnome.org/archives/gtk-devel-list/2003-January/msg00108.html
-  // "activate is probably about the only exception"
   
-/**
-   * @par Prototype:
-   * <tt>void %activate()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_activate();
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current position of the insertion cursor in chars.
+ //TODO: ignore this too? It's used in an example.
+  
+  
+  /** The current position of the insertion cursor in chars.
    *
    * 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_cursor_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The position of the opposite end of the selection from the cursor in chars.
+  /** The position of the opposite end of the selection from the cursor in chars.
    *
    * 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_selection_bound() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the entry contents can be edited.
+  /** Whether the entry contents can be edited.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the entry contents can be edited.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -423,19 +383,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Maximum number of characters for this entry. Zero if no maximum.
+  /** Maximum number of characters for this entry. Zero if no maximum.
    *
    * 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_max_length() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Maximum number of characters for this entry. Zero if no maximum.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -443,19 +399,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_max_length() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** FALSE displays the invisible char instead of the actual text (password mode).
+  /** FALSE displays the invisible char instead of the actual text (password 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<bool> property_visibility() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** FALSE displays the invisible char instead of the actual text (password mode).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -463,19 +415,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visibility() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** FALSE removes outside bevel from entry.
+  /** FALSE removes outside bevel from entry.
    *
    * 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_has_frame() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** FALSE removes outside bevel from entry.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -483,19 +431,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_frame() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The character to use when masking entry contents (in password mode).
+  /** The character to use when masking entry contents (in password 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<gunichar> property_invisible_char() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The character to use when masking entry contents (in password mode).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -503,19 +447,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<gunichar> property_invisible_char() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed.
+  /** Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed.
    *
    * 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_activates_default() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -523,19 +463,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_activates_default() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of characters to leave space for in the entry.
+  /** Number of characters to leave space for in the entry.
    *
    * 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_width_chars() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Number of characters to leave space for in the entry.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -543,30 +479,24 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_width_chars() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels of the entry scrolled off the screen to the left.
+  /** Number of pixels of the entry scrolled off the screen to the left.
    *
    * 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_scroll_offset() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The contents of the entry.
+  /** The contents of the entry.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The contents of the entry.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -574,47 +504,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The horizontal alignment
-   *
-   * 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<float> property_xalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The horizontal alignment
-   *
-   * 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<float> property_xalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to truncate multiline pastes to one line.
-   *
-   * 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_truncate_multiline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to truncate multiline pastes to one line.
-   *
-   * 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_truncate_multiline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -630,8 +519,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Entry* wrap(GtkEntry* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ENTRY_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/entrycompletion.cc b/libs/gtkmm2/gtk/gtkmm/entrycompletion.cc
index 83c619c9a8..4b7d15975d 100644
--- a/libs/gtkmm2/gtk/gtkmm/entrycompletion.cc
+++ b/libs/gtkmm2/gtk/gtkmm/entrycompletion.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/entrycompletion.h>
 #include <gtkmm/private/entrycompletion_p.h>
 
@@ -28,49 +27,71 @@
 #include <gtkmm/entry.h>
 #include <gtk/gtkentrycompletion.h>
 
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Match
+{
+public:
+  typedef Gtk::EntryCompletion::SlotMatch SlotType;
+
+  SignalProxy_Match(const SlotType& slot)
+  : slot_(slot) {}
+  
+  ~SignalProxy_Match();
+
+  static gboolean gtk_callback(GtkEntryCompletion* completion, const gchar* key, GtkTreeIter* iter, gpointer user_data);
+  static void gtk_callback_destroy(void* data);                                               
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Match::~SignalProxy_Match()
+{}
 
-static gboolean SignalProxy_Match_gtk_callback(GtkEntryCompletion* completion, const gchar* key, GtkTreeIter* iter, gpointer user_data)
+gboolean SignalProxy_Match::gtk_callback(GtkEntryCompletion* completion, const gchar* key, GtkTreeIter* iter, gpointer user_data)
 {
-  Gtk::EntryCompletion::SlotMatch* the_slot = static_cast<Gtk::EntryCompletion::SlotMatch*>(user_data);
+  SignalProxy_Match *const self = static_cast<SignalProxy_Match*>(user_data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     GtkTreeModel* tree_model = gtk_entry_completion_get_model(completion);
-    return (*the_slot)(Glib::convert_const_gchar_ptr_to_ustring(key),
+    return (self->slot_)(Glib::convert_const_gchar_ptr_to_ustring(key),
                          Gtk::TreeModel::const_iterator(tree_model, iter)
                          );
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
 
-  return false; //An arbitary default, just to avoid the compiler warning.
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
+  return FALSE; //An arbitary default, just to avoid the compiler warning.
 }
 
-static void SignalProxy_Match_gtk_callback_destroy(void* data)
+void SignalProxy_Match::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::EntryCompletion::SlotMatch*>(data);
+  delete static_cast<SignalProxy_Match*>(data);
 }
 
+} // anonymous namespace
+
 
 namespace Gtk
 {
 
 void EntryCompletion::set_match_func(const SlotMatch& slot)
 {
-  // Create a copy of the slot.  A pointer to this will be passed
+  // Create a signal proxy.  A pointer to this will be passed
   // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_Match_gtk_callback_destroy() is called.
-  SlotMatch* slot_copy = new SlotMatch(slot);
+  // when SignalProxy_Match::gtk_callback_destroy() is called.
+  SignalProxy_Match *const pSignalProxy = new SignalProxy_Match(slot);
 
   gtk_entry_completion_set_match_func(gobj(),
-      &SignalProxy_Match_gtk_callback, slot_copy,
-      &SignalProxy_Match_gtk_callback_destroy);
+      &SignalProxy_Match::gtk_callback, pSignalProxy,
+      &SignalProxy_Match::gtk_callback_destroy);
 }
 
 void EntryCompletion::insert_action_text(const Glib::ustring& text, int index)
@@ -105,7 +126,7 @@ void EntryCompletion::prepend_action_markup(const Glib::ustring& markup)
 namespace //anonymous
 {
 
-static gboolean Widget_signal_match_selected_callback(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter, void* data)
+gboolean Widget_signal_match_selected_callback(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool, const TreeModel::iterator& > SlotType;
@@ -113,31 +134,27 @@ static gboolean Widget_signal_match_selected_callback(GtkEntryCompletion* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
       {
         //This conversion is the custom-written part:
         Gtk::TreeModel::iterator cppIter(c_model, c_iter);
-
+        
         return static_cast<int>( (*static_cast<SlotType*>(slot))(cppIter) );
       }
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_match_selected_notify_callback(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter, void* data)
+gboolean Widget_signal_match_selected_notify_callback(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void, const TreeModel::iterator& > SlotType;
@@ -145,10 +162,8 @@ static gboolean Widget_signal_match_selected_notify_callback(GtkEntryCompletion*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
       {
         //This conversion is the custom-written part:
@@ -156,13 +171,11 @@ static gboolean Widget_signal_match_selected_notify_callback(GtkEntryCompletion*
 
         (*static_cast<SlotType*>(slot))(cppIter);
       }
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
@@ -182,7 +195,7 @@ const Glib::SignalProxyInfo EntryCompletion_signal_match_selected_info =
 namespace Gtk
 {
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 //Hand-coded signal wrapping:
 
 bool Gtk::EntryCompletion::on_match_selected(const TreeModel::iterator& iter)
@@ -212,22 +225,18 @@ gboolean EntryCompletion_Class::match_selected_callback_custom(GtkEntryCompletio
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
 
       //This conversion is the custom-written part:
       Gtk::TreeModel::iterator cppIter(c_model, c_iter);
       return obj->on_match_selected(cppIter);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -243,7 +252,6 @@ gboolean EntryCompletion_Class::match_selected_callback_custom(GtkEntryCompletio
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 Glib::SignalProxy1< bool, const TreeModel::iterator& > EntryCompletion::signal_match_selected()
 {
@@ -257,8 +265,7 @@ Glib::SignalProxy1< bool, const TreeModel::iterator& > EntryCompletion::signal_m
 namespace
 {
 
-
-static void EntryCompletion_signal_action_activated_callback(GtkEntryCompletion* self, gint p0,void* data)
+void EntryCompletion_signal_action_activated_callback(GtkEntryCompletion* self, gint p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,int > SlotType;
@@ -266,24 +273,20 @@ static void EntryCompletion_signal_action_activated_callback(GtkEntryCompletion*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo EntryCompletion_signal_action_activated_info =
+const Glib::SignalProxyInfo EntryCompletion_signal_action_activated_info =
 {
   "action_activated",
   (GCallback) &EntryCompletion_signal_action_activated_callback,
@@ -291,7 +294,7 @@ static const Glib::SignalProxyInfo EntryCompletion_signal_action_activated_info
 };
 
 
-static gboolean EntryCompletion_signal_insert_prefix_callback(GtkEntryCompletion* self, const gchar* p0,void* data)
+gboolean EntryCompletion_signal_insert_prefix_callback(GtkEntryCompletion* self, const gchar* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,const Glib::ustring& > SlotType;
@@ -299,27 +302,23 @@ static gboolean EntryCompletion_signal_insert_prefix_callback(GtkEntryCompletion
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean EntryCompletion_signal_insert_prefix_notify_callback(GtkEntryCompletion* self, const gchar* p0, void* data)
+gboolean EntryCompletion_signal_insert_prefix_notify_callback(GtkEntryCompletion* self, const gchar* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::ustring& > SlotType;
@@ -327,34 +326,29 @@ static gboolean EntryCompletion_signal_insert_prefix_notify_callback(GtkEntryCom
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo EntryCompletion_signal_insert_prefix_info =
+const Glib::SignalProxyInfo EntryCompletion_signal_insert_prefix_info =
 {
   "insert_prefix",
   (GCallback) &EntryCompletion_signal_insert_prefix_callback,
   (GCallback) &EntryCompletion_signal_insert_prefix_notify_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -401,19 +395,11 @@ void EntryCompletion_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->action_activated = &action_activated_callback;
     klass->match_selected = &match_selected_callback_custom;
-  #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
+  }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void EntryCompletion_Class::action_activated_callback(GtkEntryCompletion* self, gint p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -426,20 +412,16 @@ void EntryCompletion_Class::action_activated_callback(GtkEntryCompletion* self,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_action_activated(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -452,7 +434,6 @@ void EntryCompletion_Class::action_activated_callback(GtkEntryCompletion* self,
       (*base->action_activated)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* EntryCompletion_Class::wrap_new(GObject* object)
@@ -519,27 +500,32 @@ const Entry* EntryCompletion::get_entry() const
 
 void EntryCompletion::set_model(const Glib::RefPtr<TreeModel>& model)
 {
-gtk_entry_completion_set_model(gobj(), Glib::unwrap(model)); 
+  gtk_entry_completion_set_model(gobj(), Glib::unwrap(model));
 }
 
 Glib::RefPtr<TreeModel> EntryCompletion::get_model()
 {
 
   Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_entry_completion_get_model(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TreeModel> EntryCompletion::get_model() const
 {
-  return const_cast<EntryCompletion*>(this)->get_model();
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_entry_completion_get_model(const_cast<GtkEntryCompletion*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void EntryCompletion::set_minimum_key_length(int length)
 {
-gtk_entry_completion_set_minimum_key_length(gobj(), length); 
+  gtk_entry_completion_set_minimum_key_length(gobj(), length);
 }
 
 int EntryCompletion::get_minimum_key_length() const
@@ -549,22 +535,22 @@ int EntryCompletion::get_minimum_key_length() const
 
 void EntryCompletion::complete()
 {
-gtk_entry_completion_complete(gobj()); 
+  gtk_entry_completion_complete(gobj());
 }
 
 void EntryCompletion::insert_prefix()
 {
-gtk_entry_completion_insert_prefix(gobj()); 
+  gtk_entry_completion_insert_prefix(gobj());
 }
 
 void EntryCompletion::delete_action(int index)
 {
-gtk_entry_completion_delete_action(gobj(), index); 
+  gtk_entry_completion_delete_action(gobj(), index);
 }
 
 void EntryCompletion::set_inline_completion(bool inline_completion)
 {
-gtk_entry_completion_set_inline_completion(gobj(), static_cast<int>(inline_completion)); 
+  gtk_entry_completion_set_inline_completion(gobj(), static_cast<int>(inline_completion));
 }
 
 bool EntryCompletion::get_inline_completion() const
@@ -574,7 +560,7 @@ bool EntryCompletion::get_inline_completion() const
 
 void EntryCompletion::set_popup_completion(bool popup_completion)
 {
-gtk_entry_completion_set_popup_completion(gobj(), static_cast<int>(popup_completion)); 
+  gtk_entry_completion_set_popup_completion(gobj(), static_cast<int>(popup_completion));
 }
 
 bool EntryCompletion::get_popup_completion() const
@@ -582,34 +568,14 @@ bool EntryCompletion::get_popup_completion() const
   return gtk_entry_completion_get_popup_completion(const_cast<GtkEntryCompletion*>(gobj()));
 }
 
-void EntryCompletion::set_popup_set_width(bool popup_set_width)
-{
-gtk_entry_completion_set_popup_set_width(gobj(), static_cast<int>(popup_set_width)); 
-}
-
-bool EntryCompletion::get_popup_set_width() const
-{
-  return gtk_entry_completion_get_popup_set_width(const_cast<GtkEntryCompletion*>(gobj()));
-}
-
-void EntryCompletion::set_popup_single_width(bool popup_single_match)
-{
-gtk_entry_completion_set_popup_single_match(gobj(), static_cast<int>(popup_single_match)); 
-}
-
-bool EntryCompletion::get_popup_single_match() const
-{
-  return gtk_entry_completion_get_popup_single_match(const_cast<GtkEntryCompletion*>(gobj()));
-}
-
 void EntryCompletion::set_text_column(const TreeModelColumnBase& column)
 {
-gtk_entry_completion_set_text_column(gobj(), (column).index()); 
+  gtk_entry_completion_set_text_column(gobj(), (column).index());
 }
 
 void EntryCompletion::set_text_column(int column)
 {
-gtk_entry_completion_set_text_column(gobj(), column); 
+  gtk_entry_completion_set_text_column(gobj(), column);
 }
 
 int EntryCompletion::get_text_column()
@@ -623,113 +589,12 @@ Glib::SignalProxy1< void,int > EntryCompletion::signal_action_activated()
   return Glib::SignalProxy1< void,int >(this, &EntryCompletion_signal_action_activated_info);
 }
 
-
 Glib::SignalProxy1< bool,const Glib::ustring& > EntryCompletion::signal_insert_prefix()
 {
   return Glib::SignalProxy1< bool,const Glib::ustring& >(this, &EntryCompletion_signal_insert_prefix_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy< Glib::RefPtr<Gtk::TreeModel> > EntryCompletion::property_model() 
-{
-  return Glib::PropertyProxy< Glib::RefPtr<Gtk::TreeModel> >(this, "model");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> > EntryCompletion::property_model() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gtk::TreeModel> >(this, "model");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> EntryCompletion::property_minimum_key_length() 
-{
-  return Glib::PropertyProxy<int>(this, "minimum-key-length");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> EntryCompletion::property_minimum_key_length() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "minimum-key-length");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> EntryCompletion::property_text_column() 
-{
-  return Glib::PropertyProxy<int>(this, "text-column");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> EntryCompletion::property_text_column() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "text-column");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> EntryCompletion::property_inline_completion() 
-{
-  return Glib::PropertyProxy<bool>(this, "inline-completion");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> EntryCompletion::property_inline_completion() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "inline-completion");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> EntryCompletion::property_popup_completion() 
-{
-  return Glib::PropertyProxy<bool>(this, "popup-completion");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> EntryCompletion::property_popup_completion() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "popup-completion");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> EntryCompletion::property_popup_set_width() 
-{
-  return Glib::PropertyProxy<bool>(this, "popup-set-width");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> EntryCompletion::property_popup_set_width() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "popup-set-width");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> EntryCompletion::property_popup_single_match() 
-{
-  return Glib::PropertyProxy<bool>(this, "popup-single-match");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> EntryCompletion::property_popup_single_match() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "popup-single-match");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::EntryCompletion::on_action_activated(int index)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -739,10 +604,6 @@ void Gtk::EntryCompletion::on_action_activated(int index)
   if(base && base->action_activated)
     (*base->action_activated)(gobj(),index);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/entrycompletion.h b/libs/gtkmm2/gtk/gtkmm/entrycompletion.h
index d4086b2bfb..2d8e0c5bd0 100644
--- a/libs/gtkmm2/gtk/gtkmm/entrycompletion.h
+++ b/libs/gtkmm2/gtk/gtkmm/entrycompletion.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ENTRYCOMPLETION_H
 #define _GTKMM_ENTRYCOMPLETION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -42,7 +41,6 @@ namespace Gtk
 
 class Entry;
 
-//TODO: This should derive+implement from CellLayout, when we can break ABI.
 
 class EntryCompletion : public Glib::Object
 {
@@ -102,14 +100,14 @@ public:
   /** Gets the entry @a completion  has been attached to.
    * @return The entry @a completion  has been attached to.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Entry* get_entry();
   
   /** Gets the entry @a completion  has been attached to.
    * @return The entry @a completion  has been attached to.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Entry* get_entry() const;
 
@@ -118,7 +116,7 @@ public:
    * a model set, it will remove it before setting the new model.
    * If model is <tt>0</tt>, then it will unset the model.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param model The Gtk::TreeModel.
    */
   void set_model(const Glib::RefPtr<TreeModel>& model);
@@ -127,7 +125,7 @@ public:
    * Returns <tt>0</tt> if the model is unset.
    * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<TreeModel> get_model();
   
@@ -135,7 +133,7 @@ public:
    * Returns <tt>0</tt> if the model is unset.
    * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const TreeModel> get_model() const;
 
@@ -150,7 +148,7 @@ public:
    * key takes a lot of time and will come up with meaningless results anyway
    * (ie, a too large dataset).
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param length The minimum length of the key in order to start completing.
    */
   void set_minimum_key_length(int length);
@@ -158,7 +156,7 @@ public:
   /** Returns the minimum key length as set for @a completion .
    * @return The currently used minimum key length.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_minimum_key_length() const;
   
@@ -166,14 +164,14 @@ public:
    * current list with completions, using the current key. The completion list
    * view will be updated accordingly.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void complete();
 
   
   /** Requests a prefix insertion. 
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void insert_prefix();
 
@@ -193,7 +191,7 @@ public:
   
   /** Deletes the action at @a index  from @a completion 's action list.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param index The index of the item to Delete.
    */
   void delete_action(int index = 0);
@@ -202,7 +200,7 @@ public:
   /** Sets whether the common prefix of the possible completions should
    * be automatically inserted in the entry.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param inline_completion <tt>true</tt> to do inline completion.
    */
   void set_inline_completion(bool inline_completion = true);
@@ -211,13 +209,13 @@ public:
    * be automatically inserted in the entry.
    * @return <tt>true</tt> if inline completion is turned on
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_inline_completion() const;
   
   /** Sets whether the completions should be presented in a popup window.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param popup_completion <tt>true</tt> to do popup completion.
    */
   void set_popup_completion(bool popup_completion = true);
@@ -225,49 +223,11 @@ public:
   /** Returns whether the completions should be presented in a popup window.
    * @return <tt>true</tt> if popup completion is turned on
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_popup_completion() const;
 
   
-  /** Sets whether the completion popup window will be resized to be the same
-   * width as the entry.
-   * 
-   * @newin2p8
-   * @param popup_set_width <tt>true</tt> to make the width of the popup the same as the entry.
-   */
-  void set_popup_set_width(bool popup_set_width = true);
-  
-  /** Returns whether the  completion popup window will be resized to the 
-   * width of the entry.
-   * @return <tt>true</tt> if the popup window will be resized to the width of 
-   * the entry
-   * 
-   * @newin2p8.
-   */
-  bool get_popup_set_width() const;
-  
-  /** Sets whether the completion popup window will appear even if there is
-   * only a single match. You may want to set this to <tt>false</tt> if you
-   * are using inline
-   * completion.
-   * 
-   * @newin2p8
-   * @param popup_single_match <tt>true</tt> if the popup should appear even for a single
-   * match.
-   */
-  void set_popup_single_width(bool popup_single_match = true);
-  
-  /** Returns whether the completion popup window will appear even if there is
-   * only a single match.
-   * @return <tt>true</tt> if the popup window will appear regardless of the
-   * number of matches.
-   * 
-   * @newin2p8.
-   */
-  bool get_popup_single_match() const;
-
-  
   /** Convenience function for setting up the most used case of this code: a
    * completion list with just strings. This function will set up @a completion 
    * to have a list displaying all (and just) strings in the completion list,
@@ -277,7 +237,7 @@ public:
    * column. If you need to set the text column, but don't want the cell 
    * renderer, use Glib::object_set() to set the ::text_column property directly.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param column The column in the model of @a completion  to get strings from.
    */
   void set_text_column(const TreeModelColumnBase& column);
@@ -291,7 +251,7 @@ public:
    * column. If you need to set the text column, but don't want the cell 
    * renderer, use Glib::object_set() to set the ::text_column property directly.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param column The column in the model of @a completion  to get strings from.
    */
   void set_text_column(int column);
@@ -299,20 +259,11 @@ public:
   /** Returns the column in the model of @a completion  to get strings from.
    * @return The column containing the strings
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_text_column();
 
-  /** Emitted when an action is activated.
-   *
-   * @param index The index of the activated action.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %action_activated(int index)</tt>
-   */
-
   Glib::SignalProxy1< void,int > signal_action_activated();
 
 
@@ -320,15 +271,7 @@ public:
   //because we need both the iter and the model to make the C++ iter.
   
 
-  /** Emitted when a match from the list is selected. 
-   * The default behaviour is to replace the contents of the 
-   * entry with the contents of the text column in the row 
-   * pointed to by @a iter.
-   *
-   * @param model The TreeModel containing the matches
-   * @param iter A TreeModel::iterator positioned at the selected match
-   * @result true if the signal has been handled
-   * 
+  /**
    * @par Prototype:
    * <tt>bool %match_selected(const TreeModel::iterator& iter)</tt>
    */
@@ -337,194 +280,27 @@ public:
   
   //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
   //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
-  /** Emitted when the inline autocompletion is triggered. 
-   * The default behaviour is to make the entry display the 
-   * whole prefix and select the newly inserted part.
-   *
-   * Applications may connect to this signal in order to insert only a
-   * smaller part of the @a prefix into the entry - e.g. the entry used in
-   * the FileChooser inserts only the part of the prefix up to the 
-   * next '/'.
-   * 
-   * @newin2p6
-   *
-   * @param prefix The common prefix of all possible completions.
-   * @result true if the signal has been handled
-   */ 
   
-/**
-   * @par Prototype:
-   * <tt>bool %insert_prefix(const Glib::ustring& prefix)</tt>
-   */
 
   Glib::SignalProxy1< bool,const Glib::ustring& > signal_insert_prefix();
  
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The model to find matches in.
-   *
-   * 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<Gtk::TreeModel> > property_model() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The model to find matches in.
-   *
-   * 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<Gtk::TreeModel> > property_model() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Minimum length of the search key in order to look up matches.
-   *
-   * 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_minimum_key_length() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Minimum length of the search key in order to look up matches.
-   *
-   * 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_minimum_key_length() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The column of the model containing the strings.
-   *
-   * 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_text_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The column of the model containing the strings.
-   *
-   * 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_text_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the common prefix should be inserted automatically.
-   *
-   * 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_inline_completion() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the common prefix should be inserted automatically.
-   *
-   * 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_inline_completion() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the completions should be shown in a popup window.
-   *
-   * 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_popup_completion() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the completions should be shown in a popup window.
-   *
-   * 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_popup_completion() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
-   *
-   * 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_popup_set_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
-   *
-   * 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_popup_set_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
-   *
-   * 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_popup_single_match() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
-   *
-   * 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_popup_single_match() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //Default Signal Handler:
   virtual bool on_match_selected(const TreeModel::iterator& iter);        
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_action_activated(int index);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/enums.cc b/libs/gtkmm2/gtk/gtkmm/enums.cc
index 2833f83ff7..a20f39360f 100644
--- a/libs/gtkmm2/gtk/gtkmm/enums.cc
+++ b/libs/gtkmm2/gtk/gtkmm/enums.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/enums.h>
 #include <gtkmm/private/enums_p.h>
 
@@ -281,10 +280,4 @@ GType Glib::Value<Gtk::SortType>::value_type()
   return gtk_sort_type_get_type();
 }
 
-// static
-GType Glib::Value<Gtk::PageOrientation>::value_type()
-{
-  return gtk_page_orientation_get_type();
-}
-
 
diff --git a/libs/gtkmm2/gtk/gtkmm/enums.h b/libs/gtkmm2/gtk/gtkmm/enums.h
index 052f7ecf40..07d0830d40 100644
--- a/libs/gtkmm2/gtk/gtkmm/enums.h
+++ b/libs/gtkmm2/gtk/gtkmm/enums.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ENUMS_H
 #define _GTKMM_ENUMS_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -155,8 +154,7 @@ enum ArrowType
   ARROW_UP,
   ARROW_DOWN,
   ARROW_LEFT,
-  ARROW_RIGHT,
-  ARROW_NONE
+  ARROW_RIGHT
 };
 
 } // namespace Gtk
@@ -1349,38 +1347,6 @@ public:
 namespace Gtk
 {
 
-/**
- * @ingroup gtkmmEnums
- */
-enum PageOrientation
-{
-  PAGE_ORIENTATION_PORTRAIT,
-  PAGE_ORIENTATION_LANDSCAPE,
-  PAGE_ORIENTATION_REVERSE_PORTRAIT,
-  PAGE_ORIENTATION_REVERSE_LANDSCAPE
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PageOrientation> : public Glib::Value_Enum<Gtk::PageOrientation>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
 
 /* We use a class to implement the GtkIconSize enum, because you can register
  * new "enum" values.  The strict type rules of C++ don't allow using an enum
diff --git a/libs/gtkmm2/gtk/gtkmm/eventbox.cc b/libs/gtkmm2/gtk/gtkmm/eventbox.cc
index 25dc971d05..9b15790c9d 100644
--- a/libs/gtkmm2/gtk/gtkmm/eventbox.cc
+++ b/libs/gtkmm2/gtk/gtkmm/eventbox.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/eventbox.h>
 #include <gtkmm/private/eventbox_p.h>
 
@@ -28,6 +27,7 @@
 
 #include <gtk/gtkeventbox.h>
 
+
 namespace
 {
 } // anonymous namespace
@@ -74,19 +74,8 @@ void EventBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* EventBox_Class::wrap_new(GObject* o)
 {
@@ -141,7 +130,7 @@ bool EventBox::get_visible_window() const
 
 void EventBox::set_visible_window(bool visible_window)
 {
-gtk_event_box_set_visible_window(gobj(), static_cast<int>(visible_window)); 
+  gtk_event_box_set_visible_window(gobj(), static_cast<int>(visible_window));
 }
 
 bool EventBox::get_above_child() const
@@ -151,44 +140,29 @@ bool EventBox::get_above_child() const
 
 void EventBox::set_above_child(bool above_child)
 {
-gtk_event_box_set_above_child(gobj(), static_cast<int>(above_child)); 
+  gtk_event_box_set_above_child(gobj(), static_cast<int>(above_child));
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> EventBox::property_visible_window() 
 {
   return Glib::PropertyProxy<bool>(this, "visible-window");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> EventBox::property_visible_window() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-window");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> EventBox::property_above_child() 
 {
   return Glib::PropertyProxy<bool>(this, "above-child");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> EventBox::property_above_child() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "above-child");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/eventbox.h b/libs/gtkmm2/gtk/gtkmm/eventbox.h
index 74854dd095..927f196888 100644
--- a/libs/gtkmm2/gtk/gtkmm/eventbox.h
+++ b/libs/gtkmm2/gtk/gtkmm/eventbox.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_EVENTBOX_H
 #define _GTKMM_EVENTBOX_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -97,17 +96,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -120,7 +113,7 @@ public:
    * See set_visible_window() for details.
    * @return <tt>true</tt> if the event box window is visible
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_visible_window() const;
   
@@ -160,7 +153,7 @@ public:
    * descendant windows, not just at the same place on the screen.
    * &lt;/note&gt;
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param visible_window Boolean value.
    */
   void set_visible_window(bool visible_window = true);
@@ -171,7 +164,7 @@ public:
    * @return <tt>true</tt> if the event box window is above the window
    * of its child.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_above_child() const;
   
@@ -183,22 +176,19 @@ public:
    * 
    * The default is to keep the window below the child.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param above_child <tt>true</tt> if the event box window is above the windows of its child.
    */
   void set_above_child(bool above_child = true);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the event box is visible
+  /** Whether the event box is 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<bool> property_visible_window() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the event box is visible
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -206,19 +196,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible_window() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
  
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it.
+  /** Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it.
    *
    * 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_above_child() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the event-trapping window of the eventbox is above the window of the child widget as opposed to below it.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -226,7 +212,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_above_child() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
  
 
 };
@@ -242,8 +227,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::EventBox* wrap(GtkEventBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_EVENTBOX_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/expander.cc b/libs/gtkmm2/gtk/gtkmm/expander.cc
index 7a14dda085..e2c7f83908 100644
--- a/libs/gtkmm2/gtk/gtkmm/expander.cc
+++ b/libs/gtkmm2/gtk/gtkmm/expander.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/expander.h>
 #include <gtkmm/private/expander_p.h>
 
@@ -86,19 +85,8 @@ void Expander_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Expander_Class::wrap_new(GObject* o)
 {
@@ -148,7 +136,7 @@ Expander::Expander()
 
 void Expander::set_expanded(bool expanded)
 {
-gtk_expander_set_expanded(gobj(), static_cast<int>(expanded)); 
+  gtk_expander_set_expanded(gobj(), static_cast<int>(expanded));
 }
 
 bool Expander::get_expanded() const
@@ -158,7 +146,7 @@ bool Expander::get_expanded() const
 
 void Expander::set_spacing(int spacing)
 {
-gtk_expander_set_spacing(gobj(), spacing); 
+  gtk_expander_set_spacing(gobj(), spacing);
 }
 
 int Expander::get_spacing() const
@@ -168,7 +156,7 @@ int Expander::get_spacing() const
 
 void Expander::set_label(const Glib::ustring& label)
 {
-gtk_expander_set_label(gobj(), label.c_str()); 
+  gtk_expander_set_label(gobj(), label.c_str());
 }
 
 Glib::ustring Expander::get_label() const
@@ -178,7 +166,7 @@ Glib::ustring Expander::get_label() const
 
 void Expander::set_use_underline(bool use_underline)
 {
-gtk_expander_set_use_underline(gobj(), static_cast<int>(use_underline)); 
+  gtk_expander_set_use_underline(gobj(), static_cast<int>(use_underline));
 }
 
 bool Expander::get_use_underline() const
@@ -188,7 +176,7 @@ bool Expander::get_use_underline() const
 
 void Expander::set_use_markup(bool use_markup)
 {
-gtk_expander_set_use_markup(gobj(), static_cast<int>(use_markup)); 
+  gtk_expander_set_use_markup(gobj(), static_cast<int>(use_markup));
 }
 
 bool Expander::get_use_markup() const
@@ -198,7 +186,7 @@ bool Expander::get_use_markup() const
 
 void Expander::set_label_widget(Widget& label_widget)
 {
-gtk_expander_set_label_widget(gobj(), (label_widget).gobj()); 
+  gtk_expander_set_label_widget(gobj(), (label_widget).gobj());
 }
 
 Widget* Expander::get_label_widget()
@@ -208,100 +196,69 @@ Widget* Expander::get_label_widget()
 
 const Widget* Expander::get_label_widget() const
 {
-  return const_cast<Expander*>(this)->get_label_widget();
+  return Glib::wrap(gtk_expander_get_label_widget(const_cast<GtkExpander*>(gobj())));
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Expander::property_expanded() 
 {
   return Glib::PropertyProxy<bool>(this, "expanded");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Expander::property_expanded() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "expanded");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Expander::property_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Expander::property_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Expander::property_use_underline() 
 {
   return Glib::PropertyProxy<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_underline() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Expander::property_use_markup() 
 {
   return Glib::PropertyProxy<bool>(this, "use-markup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Expander::property_use_markup() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-markup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Expander::property_spacing() 
 {
   return Glib::PropertyProxy<int>(this, "spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Expander::property_spacing() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Widget*> Expander::property_label_widget() 
 {
   return Glib::PropertyProxy<Widget*>(this, "label-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Widget*> Expander::property_label_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "label-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/expander.h b/libs/gtkmm2/gtk/gtkmm/expander.h
index cb9e89894c..8f4d52b425 100644
--- a/libs/gtkmm2/gtk/gtkmm/expander.h
+++ b/libs/gtkmm2/gtk/gtkmm/expander.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_EXPANDER_H
 #define _GTKMM_EXPANDER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -43,29 +42,10 @@ namespace Gtk
 
 /** A container which can hide its child.
  *
- * An Expander allows the user to hide or show its child by clicking on an
+ * A Expander allows the user to hide or show its child by clicking on an
  * expander triangle similar to the triangles used in a Gtk::TreeView.
  *
- * Normally you use an expander as you would use any other descendant
- * of Gtk::Bin; you create the child widget and use add() to add it to 
- * the expander.  When the expander is toggled, it will take care of 
- * showing and hiding the child automatically.
- *
- * Special Usage: There are situations in which you may prefer to show and
- * hide the expanded widget yourself, such as when you want to
- * actually create the widget at expansion time.  In this case,
- * create an Expander but do not add a child to it.  The
- * expander widget has an <tt>expanded</tt> property
- * which can be used to monitor its expansion state.  You should
- * watch this property with a signal connection as follows:
- * @code
- * expander.property_expanded().signal_changed().connect(
- *   sigc::mem_fun(*this, &SomeClass::on_expander_changed)
- * );
- * @endcode
- *
  * @ingroup Widgets
- * @ingroup Containers
  */
 
 class Expander : public Bin
@@ -111,17 +91,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -132,7 +106,7 @@ public:
    *
    * The Expander has an empty label.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   Expander();
 
@@ -147,7 +121,7 @@ public:
    * @param label The string for the label describing the Expander.
    * @param mnemonic Wether the label may contain underscores to set up accelerators.
    
-   * @newin2p4
+   * Since: 2.4
    */
   explicit Expander(const Glib::ustring& label, bool mnemonic = false);
   
@@ -156,7 +130,7 @@ public:
    * the child widget to be revealed, and <tt>false</tt> if you want the
    * child widget to be hidden.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param expanded Whether the child widget is revealed.
    */
   void set_expanded(bool expanded = true);
@@ -167,7 +141,7 @@ public:
    * See set_expanded().
    * @return The current state of the expander.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_expanded() const;
 
@@ -175,7 +149,7 @@ public:
   /** Sets the spacing field of @a expander , which is the number of pixels to
    * place between expander and the child.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param spacing Distance between the expander and child in pixels.
    */
   void set_spacing(int spacing);
@@ -183,7 +157,7 @@ public:
   /** Gets the value set by set_spacing().
    * @return Spacing between the expander and child.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_spacing() const;
 
@@ -192,7 +166,7 @@ public:
    * 
    * This will also clear any previously set labels.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param label A string.
    */
   void set_label(const Glib::ustring& label);
@@ -205,7 +179,7 @@ public:
    * @return The text of the label widget. This string is owned
    * by the widget and must not be modified or freed.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_label() const;
 
@@ -213,7 +187,7 @@ public:
   /** If true, an underline in the text of the expander label indicates
    * the next character should be used for the mnemonic accelerator key.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_underline <tt>true</tt> if underlines in the text indicate mnemonics.
    */
   void set_use_underline(bool use_underline = true);
@@ -223,7 +197,7 @@ public:
    * @return <tt>true</tt> if an embedded underline in the expander label
    * indicates the mnemonic accelerator keys.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_use_underline() const;
 
@@ -231,7 +205,7 @@ public:
   /** Sets whether the text of the label contains markup in Pango's text markup
    * language. See Gtk::Label::set_markup().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_markup <tt>true</tt> if the label's text should be parsed for markup.
    */
   void set_use_markup(bool use_markup = true);
@@ -241,7 +215,7 @@ public:
    * language. See set_use_markup().
    * @return <tt>true</tt> if the label's text will be parsed for markup
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_use_markup() const;
 
@@ -249,7 +223,7 @@ public:
   /** Set the label widget for the expander. This is the widget
    * that will appear embedded alongside the expander arrow.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param label_widget The new label widget.
    */
   void set_label_widget(Widget& label_widget);
@@ -258,7 +232,7 @@ public:
    * set_label_widget().
    * @return The label widget, or <tt>0</tt> if there is none.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* get_label_widget();
   
@@ -266,23 +240,20 @@ public:
    * set_label_widget().
    * @return The label widget, or <tt>0</tt> if there is none.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* get_label_widget() const;
 
    //keybinding
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the expander has been opened to reveal the child widget.
+  /** Whether the expander has been opened to reveal the child 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<bool> property_expanded() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the expander has been opened to reveal the child widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -290,19 +261,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_expanded() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text of the expander's label.
+  /** Text of the expander's label.
    *
    * 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_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text of the expander's label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -310,19 +277,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If set
+  /** If 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<bool> property_use_underline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -330,19 +293,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The text of the label includes XML markup. See pango_parse_markup.
+  /** The text of the label includes XML markup. See pango_parse_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<bool> property_use_markup() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The text of the label includes XML markup. See pango_parse_markup.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -350,19 +309,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_markup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Space to put between the label and the child.
+  /** Space to put between the label and the child.
    *
    * 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_spacing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Space to put between the label and the child.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -370,19 +325,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_spacing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A widget to display in place of the usual expander label.
+  /** A widget to display in place of the usual expander label.
    *
    * 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<Widget*> property_label_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A widget to display in place of the usual expander label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -390,7 +341,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Widget*> property_label_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
             
 
 };
@@ -407,8 +357,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Expander* wrap(GtkExpander* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_EXPANDER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooser.cc b/libs/gtkmm2/gtk/gtkmm/filechooser.cc
index ae4be56d65..708a94365c 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooser.cc
+++ b/libs/gtkmm2/gtk/gtkmm/filechooser.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/filechooser.h>
 #include <gtkmm/private/filechooser_p.h>
 
@@ -31,8 +30,7 @@
 namespace
 {
 
-
-static const Glib::SignalProxyInfo FileChooser_signal_current_folder_changed_info =
+const Glib::SignalProxyInfo FileChooser_signal_current_folder_changed_info =
 {
   "current_folder_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -40,7 +38,7 @@ static const Glib::SignalProxyInfo FileChooser_signal_current_folder_changed_inf
 };
 
 
-static const Glib::SignalProxyInfo FileChooser_signal_selection_changed_info =
+const Glib::SignalProxyInfo FileChooser_signal_selection_changed_info =
 {
   "selection_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -48,7 +46,7 @@ static const Glib::SignalProxyInfo FileChooser_signal_selection_changed_info =
 };
 
 
-static const Glib::SignalProxyInfo FileChooser_signal_update_preview_info =
+const Glib::SignalProxyInfo FileChooser_signal_update_preview_info =
 {
   "update_preview",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -56,76 +54,13 @@ static const Glib::SignalProxyInfo FileChooser_signal_update_preview_info =
 };
 
 
-static const Glib::SignalProxyInfo FileChooser_signal_file_activated_info =
+const Glib::SignalProxyInfo FileChooser_signal_file_activated_info =
 {
   "file_activated",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
-static GtkFileChooserConfirmation FileChooser_signal_confirm_overwrite_callback(GtkFileChooser* self, void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< FileChooserConfirmation > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        return ((GtkFileChooserConfirmation)((*static_cast<SlotType*>(slot))()));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef GtkFileChooserConfirmation RType;
-  return RType();
-}
-
-static GtkFileChooserConfirmation FileChooser_signal_confirm_overwrite_notify_callback(GtkFileChooser* self,  void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef GtkFileChooserConfirmation RType;
-  return RType();
-}
-
-static const Glib::SignalProxyInfo FileChooser_signal_confirm_overwrite_info =
-{
-  "confirm-overwrite",
-  (GCallback) &FileChooser_signal_confirm_overwrite_callback,
-  (GCallback) &FileChooser_signal_confirm_overwrite_notify_callback
-};
-
-
 } // anonymous namespace
 
 // static
@@ -134,12 +69,6 @@ GType Glib::Value<Gtk::FileChooserAction>::value_type()
   return gtk_file_chooser_action_get_type();
 }
 
-// static
-GType Glib::Value<Gtk::FileChooserConfirmation>::value_type()
-{
-  return gtk_file_chooser_confirmation_get_type();
-}
-
 
 Gtk::FileChooserError::FileChooserError(Gtk::FileChooserError::Code error_code, const Glib::ustring& error_message)
 :
@@ -156,18 +85,10 @@ Gtk::FileChooserError::Code Gtk::FileChooserError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Gtk::FileChooserError::throw_func(GError* gobject)
 {
   throw Gtk::FileChooserError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Gtk::FileChooserError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Gtk::FileChooserError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 // static
 GType Glib::Value<Gtk::FileChooserError::Code>::value_type()
@@ -217,19 +138,8 @@ void FileChooser_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FileChooser_Class::wrap_new(GObject* object)
 {
@@ -273,7 +183,7 @@ GType FileChooser::get_base_type()
 
 void FileChooser::set_action(FileChooserAction action)
 {
-gtk_file_chooser_set_action(gobj(), ((GtkFileChooserAction)(action))); 
+  gtk_file_chooser_set_action(gobj(), ((GtkFileChooserAction)(action)));
 }
 
 FileChooserAction FileChooser::get_action() const
@@ -283,7 +193,7 @@ FileChooserAction FileChooser::get_action() const
 
 void FileChooser::set_local_only(bool local_only)
 {
-gtk_file_chooser_set_local_only(gobj(), static_cast<int>(local_only)); 
+  gtk_file_chooser_set_local_only(gobj(), static_cast<int>(local_only));
 }
 
 bool FileChooser::get_local_only() const
@@ -293,7 +203,7 @@ bool FileChooser::get_local_only() const
 
 void FileChooser::set_select_multiple(bool select_multiple)
 {
-gtk_file_chooser_set_select_multiple(gobj(), static_cast<int>(select_multiple)); 
+  gtk_file_chooser_set_select_multiple(gobj(), static_cast<int>(select_multiple));
 }
 
 bool FileChooser::get_select_multiple() const
@@ -303,7 +213,7 @@ bool FileChooser::get_select_multiple() const
 
 void FileChooser::set_show_hidden(bool show_hidden)
 {
-gtk_file_chooser_set_show_hidden(gobj(), static_cast<int>(show_hidden)); 
+  gtk_file_chooser_set_show_hidden(gobj(), static_cast<int>(show_hidden));
 }
 
 bool FileChooser::get_show_hidden() const
@@ -311,19 +221,9 @@ bool FileChooser::get_show_hidden() const
   return gtk_file_chooser_get_show_hidden(const_cast<GtkFileChooser*>(gobj()));
 }
 
-void FileChooser::set_do_overwrite_confirmation(bool do_overwrite_confirmation)
-{
-gtk_file_chooser_set_do_overwrite_confirmation(gobj(), static_cast<int>(do_overwrite_confirmation)); 
-}
-
-bool FileChooser::get_do_overwrite_confirmation() const
-{
-  return gtk_file_chooser_get_do_overwrite_confirmation(const_cast<GtkFileChooser*>(gobj()));
-}
-
 void FileChooser::set_current_name(const Glib::ustring& name)
 {
-gtk_file_chooser_set_current_name(gobj(), name.c_str()); 
+  gtk_file_chooser_set_current_name(gobj(), name.c_str());
 }
 
 Glib::ustring FileChooser::get_filename() const
@@ -343,17 +243,17 @@ bool FileChooser::select_filename(const Glib::ustring& filename)
 
 void FileChooser::unselect_filename(const Glib::ustring& filename)
 {
-gtk_file_chooser_unselect_filename(gobj(), filename.c_str()); 
+  gtk_file_chooser_unselect_filename(gobj(), filename.c_str());
 }
 
 void FileChooser::select_all()
 {
-gtk_file_chooser_select_all(gobj()); 
+  gtk_file_chooser_select_all(gobj());
 }
 
 void FileChooser::unselect_all()
 {
-gtk_file_chooser_unselect_all(gobj()); 
+  gtk_file_chooser_unselect_all(gobj());
 }
 
 Glib::SListHandle<Glib::ustring> FileChooser::get_filenames() const
@@ -388,7 +288,7 @@ bool FileChooser::select_uri(const Glib::ustring& uri)
 
 void FileChooser::unselect_uri(const Glib::ustring& uri)
 {
-gtk_file_chooser_unselect_uri(gobj(), uri.c_str()); 
+  gtk_file_chooser_unselect_uri(gobj(), uri.c_str());
 }
 
 Glib::SListHandle<Glib::ustring> FileChooser::get_uris() const
@@ -408,22 +308,22 @@ Glib::ustring FileChooser::get_current_folder_uri() const
 
 void FileChooser::set_preview_widget(Gtk::Widget& preview_widget)
 {
-gtk_file_chooser_set_preview_widget(gobj(), (preview_widget).gobj()); 
+  gtk_file_chooser_set_preview_widget(gobj(), (preview_widget).gobj());
 }
 
 const Gtk::Widget* FileChooser::get_preview_widget() const
 {
-  return const_cast<FileChooser*>(this)->get_preview_widget();
+  return Glib::wrap(gtk_file_chooser_get_preview_widget(const_cast<GtkFileChooser*>(gobj())));
 }
 
 Gtk::Widget* FileChooser::get_preview_widget()
 {
-  return const_cast<FileChooser*>(this)->get_preview_widget();
+  return Glib::wrap(gtk_file_chooser_get_preview_widget(gobj()));
 }
 
 void FileChooser::set_preview_widget_active(bool active)
 {
-gtk_file_chooser_set_preview_widget_active(gobj(), static_cast<int>(active)); 
+  gtk_file_chooser_set_preview_widget_active(gobj(), static_cast<int>(active));
 }
 
 bool FileChooser::get_preview_widget_active() const
@@ -433,7 +333,7 @@ bool FileChooser::get_preview_widget_active() const
 
 void FileChooser::set_use_preview_label(bool use_label)
 {
-gtk_file_chooser_set_use_preview_label(gobj(), static_cast<int>(use_label)); 
+  gtk_file_chooser_set_use_preview_label(gobj(), static_cast<int>(use_label));
 }
 
 bool FileChooser::get_use_preview_label() const
@@ -453,7 +353,7 @@ Glib::ustring FileChooser::get_preview_uri() const
 
 void FileChooser::set_extra_widget(Gtk::Widget& extra_widget)
 {
-gtk_file_chooser_set_extra_widget(gobj(), (extra_widget).gobj()); 
+  gtk_file_chooser_set_extra_widget(gobj(), (extra_widget).gobj());
 }
 
 Gtk::Widget* FileChooser::get_extra_widget()
@@ -463,17 +363,17 @@ Gtk::Widget* FileChooser::get_extra_widget()
 
 const Gtk::Widget* FileChooser::get_extra_widget() const
 {
-  return const_cast<FileChooser*>(this)->get_extra_widget();
+  return Glib::wrap(gtk_file_chooser_get_extra_widget(const_cast<GtkFileChooser*>(gobj())));
 }
 
 void FileChooser::add_filter(const FileFilter& filter)
 {
-gtk_file_chooser_add_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj())); 
+  gtk_file_chooser_add_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj()));
 }
 
 void FileChooser::remove_filter(const FileFilter& filter)
 {
-gtk_file_chooser_remove_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj())); 
+  gtk_file_chooser_remove_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj()));
 }
 
 Glib::SListHandle< FileFilter* > FileChooser::list_filters()
@@ -488,62 +388,43 @@ Glib::SListHandle< const FileFilter* > FileChooser::list_filters() const
 
 void FileChooser::set_filter(const FileFilter& filter)
 {
-gtk_file_chooser_set_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj())); 
+  gtk_file_chooser_set_filter(gobj(), const_cast<GtkFileFilter*>((filter).gobj()));
 }
 
 FileFilter* FileChooser::get_filter()
 {
 
   FileFilter* retvalue = Glib::wrap(gtk_file_chooser_get_filter(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 const FileFilter* FileChooser::get_filter() const
 {
-  return const_cast<FileChooser*>(this)->get_filter();
-}
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-bool FileChooser::add_shortcut_folder(const Glib::ustring& folder)
-#else
-bool FileChooser::add_shortcut_folder(const Glib::ustring& folder, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_file_chooser_add_shortcut_folder(gobj(), folder.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
+  const FileFilter* retvalue = Glib::wrap(gtk_file_chooser_get_filter(const_cast<GtkFileChooser*>(gobj())));
 
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
+}
 
+bool FileChooser::add_shortcut_folder(const Glib::ustring& folder)
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_add_shortcut_folder(gobj(), folder.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 bool FileChooser::remove_shortcut_folder(const Glib::ustring& folder)
-#else
-bool FileChooser::remove_shortcut_folder(const Glib::ustring& folder, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_file_chooser_remove_shortcut_folder(gobj(), folder.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_remove_shortcut_folder(gobj(), folder.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
 Glib::SListHandle<Glib::ustring> FileChooser::list_shortcut_folders() const
@@ -551,44 +432,20 @@ Glib::SListHandle<Glib::ustring> FileChooser::list_shortcut_folders() const
   return Glib::SListHandle<Glib::ustring>(gtk_file_chooser_list_shortcut_folders(const_cast<GtkFileChooser*>(gobj())), Glib::OWNERSHIP_DEEP);
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 bool FileChooser::add_shortcut_folder_uri(const Glib::ustring& uri)
-#else
-bool FileChooser::add_shortcut_folder_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_file_chooser_add_shortcut_folder_uri(gobj(), uri.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_add_shortcut_folder_uri(gobj(), uri.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 bool FileChooser::remove_shortcut_folder_uri(const Glib::ustring& uri)
-#else
-bool FileChooser::remove_shortcut_folder_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_file_chooser_remove_shortcut_folder_uri(gobj(), uri.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  bool retvalue = gtk_file_chooser_remove_shortcut_folder_uri(gobj(), uri.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
 Glib::SListHandle<Glib::ustring> FileChooser::list_shortcut_folder_uris() const
@@ -602,191 +459,121 @@ Glib::SignalProxy0< void > FileChooser::signal_current_folder_changed()
   return Glib::SignalProxy0< void >(this, &FileChooser_signal_current_folder_changed_info);
 }
 
-
 Glib::SignalProxy0< void > FileChooser::signal_selection_changed()
 {
   return Glib::SignalProxy0< void >(this, &FileChooser_signal_selection_changed_info);
 }
 
-
 Glib::SignalProxy0< void > FileChooser::signal_update_preview()
 {
   return Glib::SignalProxy0< void >(this, &FileChooser_signal_update_preview_info);
 }
 
-
 Glib::SignalProxy0< void > FileChooser::signal_file_activated()
 {
   return Glib::SignalProxy0< void >(this, &FileChooser_signal_file_activated_info);
 }
 
 
-Glib::SignalProxy0< FileChooserConfirmation > FileChooser::signal_confirm_overwrite()
-{
-  return Glib::SignalProxy0< FileChooserConfirmation >(this, &FileChooser_signal_confirm_overwrite_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<FileChooserAction> FileChooser::property_action() 
 {
   return Glib::PropertyProxy<FileChooserAction>(this, "action");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<FileChooserAction> FileChooser::property_action() const
 {
   return Glib::PropertyProxy_ReadOnly<FileChooserAction>(this, "action");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<FileFilter*> FileChooser::property_filter() 
 {
   return Glib::PropertyProxy<FileFilter*>(this, "filter");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<FileFilter*> FileChooser::property_filter() const
 {
   return Glib::PropertyProxy_ReadOnly<FileFilter*>(this, "filter");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FileChooser::property_folder_mode() 
 {
   return Glib::PropertyProxy<bool>(this, "folder-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_folder_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "folder-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FileChooser::property_local_only() 
 {
   return Glib::PropertyProxy<bool>(this, "local-only");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_local_only() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "local-only");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Widget*> FileChooser::property_preview_widget() 
 {
   return Glib::PropertyProxy<Widget*>(this, "preview-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Widget*> FileChooser::property_preview_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "preview-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FileChooser::property_preview_widget_active() 
 {
   return Glib::PropertyProxy<bool>(this, "preview-widget-active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_preview_widget_active() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "preview-widget-active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FileChooser::property_use_preview_label() 
 {
   return Glib::PropertyProxy<bool>(this, "use-preview-label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_use_preview_label() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-preview-label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Widget*> FileChooser::property_extra_widget() 
 {
   return Glib::PropertyProxy<Widget*>(this, "extra-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Widget*> FileChooser::property_extra_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "extra-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FileChooser::property_select_multiple() 
 {
   return Glib::PropertyProxy<bool>(this, "select-multiple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_select_multiple() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "select-multiple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FileChooser::property_show_hidden() 
 {
   return Glib::PropertyProxy<bool>(this, "show-hidden");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_show_hidden() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "show-hidden");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> FileChooser::property_do_overwrite_confirmation() 
-{
-  return Glib::PropertyProxy<bool>(this, "do-overwrite-confirmation");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> FileChooser::property_do_overwrite_confirmation() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "do-overwrite-confirmation");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooser.h b/libs/gtkmm2/gtk/gtkmm/filechooser.h
index 24a51c0a6f..2bbc5954ab 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooser.h
+++ b/libs/gtkmm2/gtk/gtkmm/filechooser.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FILECHOOSER_H
 #define _GTKMM_FILECHOOSER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -75,37 +74,6 @@ public:
 namespace Gtk
 {
 
-/**
- * @ingroup gtkmmEnums
- */
-enum FileChooserConfirmation
-{
-  FILE_CHOOSER_CONFIRMATION_CONFIRM,
-  FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME,
-  FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::FileChooserConfirmation> : public Glib::Value_Enum<Gtk::FileChooserConfirmation>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
 
 //TODO: //Is GTK_FILE_SYSTEM_ERROR really part of the public API? For instance, do app writers ever need to check for it?.
 //If so, then it needs to have a generated get_type() function, like the others. murrayc.
@@ -119,8 +87,7 @@ public:
   enum Code
   {
     NONEXISTENT,
-    BAD_FILENAME,
-    ALREADY_EXISTS
+    BAD_FILENAME
   };
 
   FileChooserError(Code error_code, const Glib::ustring& error_message);
@@ -129,14 +96,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
@@ -243,13 +203,13 @@ private:
 public:
 
   
-  /** Sets the type of operation that the chooser is performing; the
+  /** Sets the type of operation that that the chooser is performing; the
    * user interface is adapted to suit the selected action. For example,
    * an option to create a new folder might be shown if the action is
    * Gtk::FILE_CHOOSER_ACTION_SAVE but not if the action is
    * Gtk::FILE_CHOOSER_ACTION_OPEN.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param action The action that the file selector is performing.
    */
   void set_action(FileChooserAction action);
@@ -258,7 +218,7 @@ public:
    * set_action().
    * @return The action that the file selector is performing
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   FileChooserAction get_action() const;
   
@@ -272,7 +232,7 @@ public:
    * rather than the URI functions like
    * get_uri(),
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param local_only <tt>true</tt> if only local files can be selected.
    */
   void set_local_only(bool local_only = true);
@@ -281,7 +241,7 @@ public:
    * file selector. See set_local_only()
    * @return <tt>true</tt> if only local files can be selected.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_local_only() const;
   
@@ -290,7 +250,7 @@ public:
    * GTK_FILE_CHOOSER_ACTION_SAVE.  It cannot be set with either of the folder
    * actions.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param select_multiple <tt>true</tt> if multiple files can be selected.
    */
   void set_select_multiple(bool select_multiple = true);
@@ -299,14 +259,14 @@ public:
    * selector. See set_select_multiple().
    * @return <tt>true</tt> if multiple files can be selected.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_select_multiple() const;
 
   
   /** Sets whether hidden files and folders are displayed in the file selector.  
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param show_hidden <tt>true</tt> if hidden files and folders should be displayed.
    */
   void set_show_hidden(bool show_hidden = true);
@@ -315,49 +275,20 @@ public:
    * See set_show_hidden().
    * @return <tt>true</tt> if hidden files and folders are displayed.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_show_hidden() const;
 
   
-  /** Sets whether a file chooser in GTK_FILE_CHOOSER_ACTION_SAVE mode will present
-   * a confirmation dialog if the user types a file name that already exists.  This
-   * is <tt>false</tt> by default.
-   * 
-   * Regardless of this setting, the @a chooser  will emit the "confirm-overwrite"
-   * signal when appropriate.
-   * 
-   * If all you need is the stock confirmation dialog, set this property to <tt>true</tt>.
-   * You can override the way confirmation is done by actually handling the
-   * "confirm-overwrite" signal; please refer to its documentation for the
-   * details.
-   * 
-   * @newin2p8
-   * @param do_overwrite_confirmation Whether to confirm overwriting in save mode.
-   */
-  void set_do_overwrite_confirmation(bool do_overwrite_confirmation = true);
-  
-  /** Queries whether a file chooser is set to confirm for overwriting when the user
-   * types a file name that already exists.
-   * @return <tt>true</tt> if the file chooser will present a confirmation dialog;
-   * <tt>false</tt> otherwise.
-   * 
-   * @newin2p8.
-   */
-  bool get_do_overwrite_confirmation() const;
-
-  
   /** Sets the current name in the file selector, as if entered
    * by the user. Note that the name passed in here is a UTF-8
    * string rather than a filename. This function is meant for
    * such uses as a suggested name in a "Save As..." dialog.
    * 
-   * If you want to preselect a particular existing file, you should use
-   * set_filename() or set_uri() instead.
-   * Please see the documentation for those functions for an example of using
-   * set_current_name() as well.
+   * If you want to preselect a particular existing file, you
+   * should use set_filename() instead.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param name The filename to use, as a UTF-8 string.
    */
   void set_current_name(const Glib::ustring& name);
@@ -374,44 +305,20 @@ public:
    */
   Glib::ustring get_filename() const;
   
-  /** Sets @a filename  as the current filename for the file chooser, by changing
-   * to the file's parent folder and actually selecting the file in list.  If
-   * the @a chooser  is in Gtk::FILE_CHOOSER_ACTION_SAVE mode, the file's base name
-   * will also appear in the dialog's file name entry.
-   * 
-   * If the file name isn't in the current folder of @a chooser , then the current
-   * folder of @a chooser  will be changed to the folder containing @a filename . This
-   * is equivalent to a sequence of unselect_all() followed by
-   * select_filename().
+  /** Sets @a filename  as the current filename for the the file chooser;
+   * If the file name isn't in the current folder of @a chooser , then the
+   * current folder of @a chooser  will be changed to the folder containing
+   *  @a filename . This is equivalent to a sequence of
+   * unselect_all() followed by select_filename().
    * 
    * Note that the file must exist, or nothing will be done except
-   * for the directory change.
-   * 
-   * If you are implementing a &lt;guimenuitem&gt;File/Save As...&lt;/guimenuitem&gt; dialog, you
-   * should use this function if you already have a file name to which the user may save; for example,
-   * when the user opens an existing file and then does &lt;guimenuitem&gt;File/Save As...&lt;/guimenuitem&gt;
-   * on it.  If you don't have a file name already  @htmlonly&mdash;@endhtmlonly  for example, if the user just created
-   * a new file and is saving it for the first time, do not call this function.  Instead, use
-   * something similar to this:
-   * 
-   * 
-   * if (document_is_new)
-   * {
-   * /&lt;!-- --&gt;* the user just created a new document *&lt;!-- --&gt;/
-   * gtk_file_chooser_set_current_folder (chooser, default_folder_for_saving);
-   * gtk_file_chooser_set_current_name (chooser, "Untitled document");
-   * }
-   * else
-   * {
-   * /&lt;!-- --&gt;* the user edited an existing document *&lt;!-- --&gt;/ 
-   * gtk_file_chooser_set_filename (chooser, existing_filename);
-   * }
-   * 
+   * for the directory change. To pre-enter a filename for the user, as in
+   * a save-as dialog, use set_current_name()
    * @param filename The filename to set as current.
    * @return <tt>true</tt> if both the folder could be changed and the file was
    * selected successfully, <tt>false</tt> otherwise.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool set_filename(const Glib::ustring& filename);
   
@@ -422,7 +329,7 @@ public:
    * @return <tt>true</tt> if both the folder could be changed and the file was
    * selected successfully, <tt>false</tt> otherwise.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool select_filename(const Glib::ustring& filename);
   
@@ -430,20 +337,20 @@ public:
    * is not in the current directory, does not exist, or
    * is otherwise not currently selected, does nothing.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param filename The filename to unselect.
    */
   void unselect_filename(const Glib::ustring& filename);
   
   /** Selects all the files in the current folder of a file chooser.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void select_all();
   
   /** Unselects all the files in the current folder of a file chooser.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void unselect_all();
   
@@ -455,7 +362,7 @@ public:
    * files and subfolders in the current folder. Free the returned list
    * with Glib::slist_free(), and the filenames with Glib::free().
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle<Glib::ustring> get_filenames() const;
   
@@ -466,19 +373,17 @@ public:
    * @return <tt>true</tt> if the folder could be changed successfully, <tt>false</tt>
    * otherwise.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool set_current_folder(const Glib::ustring& filename);
   
   /** Gets the current folder of @a chooser  as a local filename.
    * See set_current_folder().
-   * @return The full path of the current folder, or <tt>0</tt> if the current
-   * path cannot be represented as a local filename.  Free with Glib::free().  This
-   * function will also return <tt>0</tt> if the file chooser was unable to load the
-   * last folder that was requested from it; for example, as would be for calling
-   * set_current_folder() on a nonexistent folder.
+   * @return The full path of the current folder, or <tt>0</tt>
+   * if the current path cannot be represented as a local filename.
+   * Free with Glib::free().
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_current_folder() const;
 
@@ -497,43 +402,20 @@ public:
    */
   Glib::ustring get_uri() const;
   
-  /** Sets the file referred to by @a uri  as the current file for the file chooser,
-   * by changing to the URI's parent folder and actually selecting the URI in the
-   * list.  If the @a chooser  is Gtk::FILE_CHOOSER_ACTION_SAVE mode, the URI's base
-   * name will also appear in the dialog's file name entry.
-   * 
-   * If the URI isn't in the current folder of @a chooser , then the current folder
-   * of @a chooser  will be changed to the folder containing @a uri . This is equivalent
-   * to a sequence of unselect_all() followed by
-   * select_uri().
-   * 
-   * Note that the URI must exist, or nothing will be done except
-   * for the directory change.
-   * If you are implementing a &lt;guimenuitem&gt;File/Save As...&lt;/guimenuitem&gt; dialog, you
-   * should use this function if you already have a file name to which the user may save; for example,
-   * when the user opens an existing file and then does &lt;guimenuitem&gt;File/Save As...&lt;/guimenuitem&gt;
-   * on it.  If you don't have a file name already  @htmlonly&mdash;@endhtmlonly  for example, if the user just created
-   * a new file and is saving it for the first time, do not call this function.  Instead, use
-   * something similar to this:
-   * 
-   * 
-   * if (document_is_new)
-   * {
-   * /&lt;!-- --&gt;* the user just created a new document *&lt;!-- --&gt;/
-   * gtk_file_chooser_set_current_folder_uri (chooser, default_folder_for_saving);
-   * gtk_file_chooser_set_current_name (chooser, "Untitled document");
-   * }
-   * else
-   * {
-   * /&lt;!-- --&gt;* the user edited an existing document *&lt;!-- --&gt;/ 
-   * gtk_file_chooser_set_uri (chooser, existing_uri);
-   * }
+  /** Sets the file referred to by @a uri  as the current file for the the
+   * file chooser; If the file name isn't in the current folder of @a chooser ,
+   * then the current folder of @a chooser  will be changed to the folder containing
+   *  @a uri . This is equivalent to a sequence of unselect_all()
+   * followed by select_uri().
    * 
+   * Note that the file must exist, or nothing will be done except
+   * for the directory change. To pre-enter a filename for the user, as in
+   * a save-as dialog, use set_current_name()
    * @param uri The URI to set as current.
    * @return <tt>true</tt> if both the folder could be changed and the URI was
    * selected successfully, <tt>false</tt> otherwise.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool set_uri(const Glib::ustring& uri);
   
@@ -544,7 +426,7 @@ public:
    * @return <tt>true</tt> if both the folder could be changed and the URI was
    * selected successfully, <tt>false</tt> otherwise.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool select_uri(const Glib::ustring& uri);
   
@@ -552,7 +434,7 @@ public:
    * is not in the current directory, does not exist, or
    * is otherwise not currently selected, does nothing.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param uri The URI to unselect.
    */
   void unselect_uri(const Glib::ustring& uri);
@@ -563,7 +445,7 @@ public:
    * files and subfolders in the current folder. Free the returned list
    * with Glib::slist_free(), and the filenames with Glib::free().
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle<Glib::ustring> get_uris() const;
 
@@ -575,7 +457,7 @@ public:
    * @return <tt>true</tt> if the folder could be changed successfully, <tt>false</tt>
    * otherwise.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool set_current_folder_uri(const Glib::ustring& uri);
   
@@ -602,7 +484,7 @@ public:
    * may display an internally generated preview of the current file or
    * it may display no preview at all.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param preview_widget Widget for displaying preview.
    */
   void set_preview_widget(Gtk::Widget& preview_widget);
@@ -611,7 +493,7 @@ public:
    * set_preview_widget().
    * @return The current preview widget, or <tt>0</tt>
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Gtk::Widget* get_preview_widget() const;
   
@@ -619,18 +501,18 @@ public:
    * set_preview_widget().
    * @return The current preview widget, or <tt>0</tt>
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Gtk::Widget* get_preview_widget();
   
   /** Sets whether the preview widget set by
-   * set_preview_widget() should be shown for the
+   * set_preview_widget_active() should be shown for the
    * current filename. When @a active  is set to false, the file chooser
    * may display an internally generated preview of the current file
    * or it may display no preview at all. See
    * set_preview_widget() for more details.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param active Whether to display the user-specified preview widget.
    */
   void set_preview_widget_active(bool active = true);
@@ -640,7 +522,7 @@ public:
    * set_preview_widget_active().
    * @return <tt>true</tt> if the preview widget is active for the current filename.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_preview_widget_active() const;
 
@@ -652,7 +534,7 @@ public:
    * 
    * See also: set_preview_widget()
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_label Whether to display a stock label with the name of the previewed file.
    */
   void set_use_preview_label(bool use_label = true);
@@ -685,7 +567,7 @@ public:
   
   /** Sets an application-supplied widget to provide extra options to the user.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param extra_widget Widget for extra options.
    */
   void set_extra_widget(Gtk::Widget& extra_widget);
@@ -694,7 +576,7 @@ public:
    * set_extra_widget().
    * @return The current extra widget, or <tt>0</tt>
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Gtk::Widget* get_extra_widget();
   
@@ -702,7 +584,7 @@ public:
    * set_extra_widget().
    * @return The current extra widget, or <tt>0</tt>
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Gtk::Widget* get_extra_widget() const;
 
@@ -711,19 +593,16 @@ public:
   
   /** Adds @a filter  to the list of filters that the user can select between.
    * When a filter is selected, only files that are passed by that
-   * filter are displayed. 
-   * 
-   * Note that the @a chooser  takes ownership of the filter, so you have to 
-   * ref and sink it if you want to keep a reference.
+   * filter are displayed.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param filter A Gtk::FileFilter.
    */
   void add_filter(const FileFilter& filter);
   
   /** Removes @a filter  from the list of filters that the user can select between.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param filter A Gtk::FileFilter.
    */
   void remove_filter (const FileFilter& filter);
@@ -736,7 +615,7 @@ public:
    * owned by GTK+, but you must free the list itself with
    * Glib::slist_free() when you are done with it.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle< FileFilter* > list_filters();
   
@@ -747,7 +626,7 @@ public:
    * owned by GTK+, but you must free the list itself with
    * Glib::slist_free() when you are done with it.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle< const FileFilter* > list_filters() const;
   
@@ -761,7 +640,7 @@ public:
    * filters is empty is useful if you want to restrict the displayed
    * set of files without letting the user change it.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param filter A Gtk::FileFilter.
    */
   void set_filter(const FileFilter& filter);
@@ -769,14 +648,14 @@ public:
   /** Gets the current filter; see set_filter().
    * @return The current filter, or <tt>0</tt>
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   FileFilter* get_filter();
   
   /** Gets the current filter; see set_filter().
    * @return The current filter, or <tt>0</tt>
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const FileFilter* get_filter() const;
   
@@ -791,14 +670,9 @@ public:
    * @return <tt>true</tt> if the folder could be added successfully, <tt>false</tt>
    * otherwise.  In the latter case, the @a error  will be set as appropriate.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   bool add_shortcut_folder(const Glib::ustring& folder);
-#else
-  bool add_shortcut_folder(const Glib::ustring& folder, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   
   /** Removes a folder from a file chooser's list of shortcut folders.
    * @param folder Filename of the folder to remove.
@@ -807,21 +681,17 @@ public:
    * 
    * See also: add_shortcut_folder()
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   bool remove_shortcut_folder(const Glib::ustring& folder);
-#else
-  bool remove_shortcut_folder(const Glib::ustring& folder, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   
   /** Queries the list of shortcut folders in the file chooser, as set by
    * add_shortcut_folder().
+   * @return A list of folder filenames, or <tt>0</tt> if there are no shortcut
+   * folders.  Free the returned list with Glib::slist_free(), and the filenames with
+   * Glib::free().
    * 
-   * @newin2p4
-   * @return A list of folder filenames, if there are any shortcut
-   * folders..
+   * Since: 2.4.
    */
   Glib::SListHandle<Glib::ustring> list_shortcut_folders() const;
 
@@ -834,14 +704,9 @@ public:
    * @return <tt>true</tt> if the folder could be added successfully, <tt>false</tt>
    * otherwise.  In the latter case, the @a error  will be set as appropriate.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   bool add_shortcut_folder_uri(const Glib::ustring& uri);
-#else
-  bool add_shortcut_folder_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   
   /** Removes a folder URI from a file chooser's list of shortcut folders.
    * @param uri URI of the folder to remove.
@@ -850,14 +715,9 @@ public:
    * 
    * See also: add_shortcut_folder_uri()
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   bool remove_shortcut_folder_uri(const Glib::ustring& uri);
-#else
-  bool remove_shortcut_folder_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   
   /** Queries the list of shortcut folders in the file chooser, as set by
    * add_shortcut_folder_uri().
@@ -865,121 +725,31 @@ public:
    * folders.  Free the returned list with Glib::slist_free(), and the URIs with
    * Glib::free().
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle<Glib::ustring> list_shortcut_folder_uris() const;
 
-  
-  /** This signal is emitted when the current folder in a FileChooser
-   * changes.  This can happen due to the user performing some action that
-   * changes folders, such as selecting a bookmark or visiting a folder on the
-   * file list.  It can also happen as a result of calling a function to
-   * explicitly change the current folder in a file chooser.
-   *
-   * Normally you do not need to connect to this signal, unless you need to keep
-   * track of which folder a file chooser is showing.
-   *
-   * @see set_current_folder(), get_current_folder(),
-   * set_current_folder_uri(), get_current_folder_uri().
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %current_folder_changed()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_current_folder_changed();
 
   
-  /** This signal is emitted when there is a change in the set of selected files
-   * in a #GtkFileChooser.  This can happen when the user modifies the selection
-   * with the mouse or the keyboard, or when explicitly calling functions to
-   * change the selection.
-   *
-   * Normally you do not need to connect to this signal, as it is easier to wait
-   * for the file chooser to finish running, and then to get the list of
-   * selected files using the functions mentioned below.
-   *
-   * @see select_filename(), unselect_filename(), get_filename(),
-   * get_filenames(), select_uri(),
-   * unselect_uri(), get_uri(),
-   * get_uris().
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %selection_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_selection_changed();
 
   
-  /** This signal is emitted when the preview in a file chooser should be
-   * regenerated.  For example, this can happen when the currently selected file
-   * changes.  You should use this signal if you want your file chooser to have
-   * a preview widget.
-   *
-   * Once you have installed a preview widget with
-   * set_preview_widget(), you should update it when this
-   * signal is emitted.  You can use the functions
-   * get_preview_filename() or get_preview_uri() to get the name of the file to preview.
-   * Your widget may not be able to preview all kinds of files; your signal handler
-   * must call set_preview_wiget_active() to inform the file
-   * chooser about whether the preview was generated successfully or not.
-   *
-   * @see set_preview_widget(), set_preview_widget_active(),
-   * set_use_preview_label(), get_preview_filename(), get_preview_uri().
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %update_preview()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_update_preview();
 
   
-  /** This signal is emitted when the user "activates" a file in the file
-   * chooser.  This can happen by double-clicking on a file in the file list, or
-   * by pressing <keycap>Enter</keycap>.
-   *
-   * Normally you do not need to connect to this signal.  It is used internally
-   * by FileChooserDialog to know when to activate the default button in the
-   * dialog.
-   *
-   * @see get_filename(), get_filenames(), get_uri(), get_uris().
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %file_activated()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_file_activated();
 
 
-  /** TODO
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>FileChooserConfirmation %confirm_overwrite()</tt>
-   */
-
-  Glib::SignalProxy0< FileChooserConfirmation > signal_confirm_overwrite();
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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<FileChooserAction> property_action() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -987,20 +757,16 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<FileChooserAction> property_action() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
   //TODO: _WRAP_PROPERTY("file-system", FileSystem) //FileSystem is not really public API.
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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<FileFilter*> property_filter() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1008,19 +774,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<FileFilter*> property_filter() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_folder_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1028,19 +790,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_folder_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_local_only() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1048,19 +806,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_local_only() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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<Widget*> property_preview_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1068,19 +822,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Widget*> property_preview_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_preview_widget_active() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1088,19 +838,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_preview_widget_active() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_use_preview_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1108,19 +854,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_preview_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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<Widget*> property_extra_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1128,19 +870,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Widget*> property_extra_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_select_multiple() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1148,19 +886,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_select_multiple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_show_hidden() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1168,44 +902,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_show_hidden() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_do_overwrite_confirmation() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_do_overwrite_confirmation() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -1224,6 +931,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_FILECHOOSER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserbutton.cc b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.cc
index 730a0f70c4..ebdc540ddd 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooserbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/filechooserbutton.h>
 #include <gtkmm/private/filechooserbutton_p.h>
 
@@ -89,19 +88,8 @@ void FileChooserButton_Class::class_init_function(void* g_class, void* class_dat
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FileChooserButton_Class::wrap_new(GObject* o)
 {
@@ -170,7 +158,7 @@ Glib::ustring FileChooserButton::get_title() const
 
 void FileChooserButton::set_title(const Glib::ustring& title)
 {
-gtk_file_chooser_button_set_title(gobj(), title.c_str()); 
+  gtk_file_chooser_button_set_title(gobj(), title.c_str());
 }
 
 int FileChooserButton::get_width_chars() const
@@ -180,75 +168,34 @@ int FileChooserButton::get_width_chars() const
 
 void FileChooserButton::set_width_chars(int n_chars)
 {
-gtk_file_chooser_button_set_width_chars(gobj(), n_chars); 
-}
-
-bool FileChooserButton::get_focus_on_click() const
-{
-  return gtk_file_chooser_button_get_focus_on_click(const_cast<GtkFileChooserButton*>(gobj()));
-}
-
-void FileChooserButton::set_focus_on_click(gboolean focus_on_click)
-{
-gtk_file_chooser_button_set_focus_on_click(gobj(), focus_on_click); 
+  gtk_file_chooser_button_set_width_chars(gobj(), n_chars);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<FileChooserDialog*> FileChooserButton::property_dialog() const
 {
   return Glib::PropertyProxy_ReadOnly<FileChooserDialog*>(this, "dialog");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> FileChooserButton::property_focus_on_click() 
-{
-  return Glib::PropertyProxy<bool>(this, "focus-on-click");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> FileChooserButton::property_focus_on_click() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "focus-on-click");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> FileChooserButton::property_title() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> FileChooserButton::property_title() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> FileChooserButton::property_width_chars() 
 {
   return Glib::PropertyProxy<int>(this, "width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> FileChooserButton::property_width_chars() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserbutton.h b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.h
index a6de8ea035..0865ac58e6 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooserbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FILECHOOSERBUTTON_H
 #define _GTKMM_FILECHOOSERBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -102,17 +101,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -153,13 +146,13 @@ public:
    * should not be modified or freed.
    * @return A pointer to the browse dialog's title.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::ustring get_title() const;
   
   /** Modifies the @a title  of the browse dialog used by @a button .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param title The new browse dialog title.
    */
   void set_title(const Glib::ustring& title);
@@ -168,64 +161,35 @@ public:
   /** Retrieves the width in characters of the @a button  widget's entry and/or label.
    * @return An integer width (in characters) that the button will use to size itself.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_width_chars() const;
   
   /** Sets the width (in characters) that @a button  will use to @a n_chars .
    * 
-   * @newin2p6
-   * @param n_chars The new width, in characters.
+   * Since: 2.6
+   * @param n_chars The new width, in chracters.
    */
   void set_width_chars(int n_chars);
 
-  
-  bool get_focus_on_click() const;
-  
-  void set_focus_on_click(gboolean focus_on_click = true);   
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The file chooser dialog to use.
+  /** The file chooser dialog to use.
    *
    * 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<FileChooserDialog*> property_dialog() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the button grabs focus when it is clicked with the mouse.
-   *
-   * 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_focus_on_click() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the button grabs focus when it is clicked with the mouse.
-   *
-   * 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_focus_on_click() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The title of the file chooser dialog.
+  /** The title of the file chooser dialog.
    *
    * 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_title() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The title of the file chooser dialog.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -233,19 +197,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
                                           
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The desired width of the button widget
+  /** The desired width of the button 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<int> property_width_chars() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The desired width of the button widget
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -253,7 +213,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_width_chars() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
     
 
 };
@@ -270,8 +229,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FileChooserButton* wrap(GtkFileChooserButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FILECHOOSERBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserdialog.cc b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.cc
index dc48e4337c..88dc4078e5 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooserdialog.cc
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/filechooserdialog.h>
 #include <gtkmm/private/filechooserdialog_p.h>
 
@@ -112,19 +111,8 @@ void FileChooserDialog_Class::class_init_function(void* g_class, void* class_dat
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FileChooserDialog_Class::wrap_new(GObject* o)
 {
@@ -165,13 +153,6 @@ GType FileChooserDialog::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserdialog.h b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.h
index e6c818c1dc..08ba746815 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooserdialog.h
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserdialog.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FILECHOOSERDIALOG_H
 #define _GTKMM_FILECHOOSERDIALOG_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -92,17 +91,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -131,8 +124,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FileChooserDialog* wrap(GtkFileChooserDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FILECHOOSERDIALOG_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserwidget.cc b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.cc
index 59d9fece59..db14e802eb 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooserwidget.cc
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/filechooserwidget.h>
 #include <gtkmm/private/filechooserwidget_p.h>
 
@@ -82,19 +81,8 @@ void FileChooserWidget_Class::class_init_function(void* g_class, void* class_dat
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FileChooserWidget_Class::wrap_new(GObject* o)
 {
@@ -157,13 +145,6 @@ FileChooserWidget::FileChooserWidget(FileChooserAction action, const Glib::ustri
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filechooserwidget.h b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.h
index 2a40a95b94..fa8afffd6c 100644
--- a/libs/gtkmm2/gtk/gtkmm/filechooserwidget.h
+++ b/libs/gtkmm2/gtk/gtkmm/filechooserwidget.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FILECHOOSERWIDGET_H
 #define _GTKMM_FILECHOOSERWIDGET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -97,17 +96,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -123,7 +116,7 @@ public:
    *
    * @param action Open or save mode for the widget
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   explicit FileChooserWidget(FileChooserAction action);
   explicit FileChooserWidget(FileChooserAction action, const Glib::ustring& backend);
@@ -142,8 +135,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FileChooserWidget* wrap(GtkFileChooserWidget* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FILECHOOSERWIDGET_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filefilter.cc b/libs/gtkmm2/gtk/gtkmm/filefilter.cc
index 4c6bc09958..72c921934d 100644
--- a/libs/gtkmm2/gtk/gtkmm/filefilter.cc
+++ b/libs/gtkmm2/gtk/gtkmm/filefilter.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/filefilter.h>
 #include <gtkmm/private/filefilter_p.h>
 
@@ -27,14 +26,41 @@
 #include <gtk/gtkfilefilter.h>
 #include <gtk/gtktypebuiltins.h> //For gtk_file_filter_flags_get_type().
 
-static gboolean SignalProxy_Custom_gtk_callback(const GtkFileFilterInfo* filter_info, gpointer data)
+namespace
+{
+
+//SignalProxy_Custom:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Custom
 {
-  Gtk::FileFilter::SlotCustom* the_slot = static_cast<Gtk::FileFilter::SlotCustom*>(data);
+public:
+  typedef Gtk::FileFilter::SlotCustom SlotType;
+
+  SignalProxy_Custom(const SlotType& slot);
+  ~SignalProxy_Custom();
+
+  static gboolean gtk_callback(const GtkFileFilterInfo* filter_info, gpointer data);
+  static void gtk_callback_destroy(void* data);
+  
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_Custom::SignalProxy_Custom(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Custom::~SignalProxy_Custom()
+{}
+
+gboolean SignalProxy_Custom::gtk_callback(const GtkFileFilterInfo* filter_info, gpointer data)
+{
+  SignalProxy_Custom *const self = static_cast<SignalProxy_Custom*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     //Create a suitable C++ instance to pass to the C++ method:
     Gtk::FileFilter::Info cppInfo;
     cppInfo.contains = (Gtk::FileFilterFlags)filter_info->contains;
@@ -43,36 +69,35 @@ static gboolean SignalProxy_Custom_gtk_callback(const GtkFileFilterInfo* filter_
     cppInfo.display_name = Glib::convert_const_gchar_ptr_to_ustring(filter_info->display_name);
     cppInfo.mime_type = Glib::convert_const_gchar_ptr_to_ustring(filter_info->mime_type);
   
-    return (*the_slot)(cppInfo);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    return (self->slot_)(cppInfo);
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
     return false; //arbitrary default;
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void SignalProxy_Custom_gtk_callback_destroy(void* data)
+void SignalProxy_Custom::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::FileFilter::SlotCustom*>(data);
+  delete static_cast<SignalProxy_Custom*>(data);
 }
 
+} //anonymous namespace
 
 namespace Gtk
 {
 
 void FileFilter::add_custom(FileFilterFlags needed, const SlotCustom& slot)
 {
-  //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
   //It will be deleted when SignalProxy_Custom::gtk_callback_destroy() is called.
-  SlotCustom* slot_copy = new SlotCustom(slot);
+  SignalProxy_Custom *const pSignalProxy = new SignalProxy_Custom(slot);
       
   gtk_file_filter_add_custom(gobj(), (GtkFileFilterFlags)needed,
-                             &SignalProxy_Custom_gtk_callback,
-                             slot_copy,
-                             &SignalProxy_Custom_gtk_callback_destroy);     
+                             &SignalProxy_Custom::gtk_callback,
+                             pSignalProxy,
+                             &SignalProxy_Custom::gtk_callback_destroy);     
 }
  
 } // namespace Gtk
@@ -130,19 +155,8 @@ void FileFilter_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FileFilter_Class::wrap_new(GObject* o)
 {
@@ -192,7 +206,7 @@ FileFilter::FileFilter()
 
 void FileFilter::set_name(const Glib::ustring& name)
 {
-gtk_file_filter_set_name(gobj(), name.c_str()); 
+  gtk_file_filter_set_name(gobj(), name.c_str());
 }
 
 Glib::ustring FileFilter::get_name() const
@@ -202,17 +216,17 @@ Glib::ustring FileFilter::get_name() const
 
 void FileFilter::add_mime_type(const Glib::ustring& mime_type)
 {
-gtk_file_filter_add_mime_type(gobj(), mime_type.c_str()); 
+  gtk_file_filter_add_mime_type(gobj(), mime_type.c_str());
 }
 
 void FileFilter::add_pattern(const Glib::ustring& pattern)
 {
-gtk_file_filter_add_pattern(gobj(), pattern.c_str()); 
+  gtk_file_filter_add_pattern(gobj(), pattern.c_str());
 }
 
 void FileFilter::add_pixbuf_formats()
 {
-gtk_file_filter_add_pixbuf_formats(gobj()); 
+  gtk_file_filter_add_pixbuf_formats(gobj());
 }
 
 FileFilterFlags FileFilter::get_needed() const
@@ -221,13 +235,6 @@ FileFilterFlags FileFilter::get_needed() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/filefilter.h b/libs/gtkmm2/gtk/gtkmm/filefilter.h
index fd5aadf8c4..1800856266 100644
--- a/libs/gtkmm2/gtk/gtkmm/filefilter.h
+++ b/libs/gtkmm2/gtk/gtkmm/filefilter.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FILEFILTER_H
 #define _GTKMM_FILEFILTER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -159,17 +158,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -182,7 +175,7 @@ public:
    * that will be displayed in the file selector user interface if
    * there is a selectable list of filters.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param name The human-readable-name for the filter, or <tt>0</tt>
    * to remove any existing name.
    */
@@ -193,21 +186,21 @@ public:
    * or <tt>0</tt>. This value is owned by GTK+ and must not
    * be modified or freed.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_name() const;
 
   
   /** Adds a rule allowing a given mime type to @a filter .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param mime_type Name of a MIME type.
    */
   void add_mime_type(const Glib::ustring& mime_type);
   
   /** Adds a rule allowing a shell style glob to a filter.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param pattern A shell style glob.
    */
   void add_pattern(const Glib::ustring& pattern);
@@ -215,7 +208,7 @@ public:
   /** Adds a rule allowing image files in the formats supported
    * by GdkPixbuf.
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void add_pixbuf_formats();
 
@@ -244,7 +237,7 @@ public:
    * @return Bitfield of flags indicating needed fields when
    * calling gtk_file_filter_filter()
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   FileFilterFlags get_needed() const;
 
@@ -266,8 +259,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FileFilter* wrap(GtkFileFilter* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FILEFILTER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/fileselection.cc b/libs/gtkmm2/gtk/gtkmm/fileselection.cc
index 4a5f387047..9379da1c9f 100644
--- a/libs/gtkmm2/gtk/gtkmm/fileselection.cc
+++ b/libs/gtkmm2/gtk/gtkmm/fileselection.cc
@@ -1,8 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <gtkmm/fileselection.h>
 #include <gtkmm/private/fileselection_p.h>
 
@@ -91,19 +88,8 @@ void FileSelection_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FileSelection_Class::wrap_new(GObject* o)
 {
@@ -153,7 +139,7 @@ FileSelection::FileSelection(const Glib::ustring& title)
 
 void FileSelection::set_filename(const std::string& filename)
 {
-gtk_file_selection_set_filename(gobj(), (filename).c_str()); 
+  gtk_file_selection_set_filename(gobj(), (filename).c_str());
 }
 
 std::string FileSelection::get_filename() const
@@ -163,17 +149,17 @@ std::string FileSelection::get_filename() const
 
 void FileSelection::complete(const Glib::ustring& pattern)
 {
-gtk_file_selection_complete(gobj(), pattern.c_str()); 
+  gtk_file_selection_complete(gobj(), pattern.c_str());
 }
 
 void FileSelection::show_fileop_buttons()
 {
-gtk_file_selection_show_fileop_buttons(gobj()); 
+  gtk_file_selection_show_fileop_buttons(gobj());
 }
 
 void FileSelection::hide_fileop_buttons()
 {
-gtk_file_selection_hide_fileop_buttons(gobj()); 
+  gtk_file_selection_hide_fileop_buttons(gobj());
 }
 
 Glib::ArrayHandle<std::string> FileSelection::get_selections() const
@@ -183,7 +169,7 @@ Glib::ArrayHandle<std::string> FileSelection::get_selections() const
 
 void FileSelection::set_select_multiple(bool select_multiple)
 {
-gtk_file_selection_set_select_multiple(gobj(), static_cast<int>(select_multiple)); 
+  gtk_file_selection_set_select_multiple(gobj(), static_cast<int>(select_multiple));
 }
 
 bool FileSelection::get_select_multiple() const
@@ -191,7 +177,7 @@ bool FileSelection::get_select_multiple() const
   return gtk_file_selection_get_select_multiple(const_cast<GtkFileSelection*>(gobj()));
 }
 
- TreeView* FileSelection::get_dir_list()
+TreeView* FileSelection::get_dir_list()
 {
   return Glib::wrap((GtkTreeView*)(gobj()->dir_list));
 }
@@ -200,8 +186,8 @@ const TreeView* FileSelection::get_dir_list() const
 {
   return Glib::wrap((GtkTreeView*)(gobj()->dir_list));
 }
- 
- TreeView* FileSelection::get_file_list()
+
+TreeView* FileSelection::get_file_list()
 {
   return Glib::wrap((GtkTreeView*)(gobj()->file_list));
 }
@@ -210,8 +196,8 @@ const TreeView* FileSelection::get_file_list() const
 {
   return Glib::wrap((GtkTreeView*)(gobj()->file_list));
 }
- 
- OptionMenu* FileSelection::get_history_pulldown()
+
+OptionMenu* FileSelection::get_history_pulldown()
 {
   return Glib::wrap((GtkOptionMenu*)(gobj()->history_pulldown));
 }
@@ -220,8 +206,8 @@ const OptionMenu* FileSelection::get_history_pulldown() const
 {
   return Glib::wrap((GtkOptionMenu*)(gobj()->history_pulldown));
 }
- 
- Entry* FileSelection::get_selection_entry()
+
+Entry* FileSelection::get_selection_entry()
 {
   return Glib::wrap((GtkEntry*)(gobj()->selection_entry));
 }
@@ -230,8 +216,8 @@ const Entry* FileSelection::get_selection_entry() const
 {
   return Glib::wrap((GtkEntry*)(gobj()->selection_entry));
 }
- 
- Label* FileSelection::get_selection_text()
+
+Label* FileSelection::get_selection_text()
 {
   return Glib::wrap((GtkLabel*)(gobj()->selection_text));
 }
@@ -240,8 +226,8 @@ const Label* FileSelection::get_selection_text() const
 {
   return Glib::wrap((GtkLabel*)(gobj()->selection_text));
 }
- 
- VBox* FileSelection::get_main_vbox()
+
+VBox* FileSelection::get_main_vbox()
 {
   return Glib::wrap((GtkVBox*)(gobj()->main_vbox));
 }
@@ -250,8 +236,8 @@ const VBox* FileSelection::get_main_vbox() const
 {
   return Glib::wrap((GtkVBox*)(gobj()->main_vbox));
 }
- 
- Button* FileSelection::get_ok_button()
+
+Button* FileSelection::get_ok_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->ok_button));
 }
@@ -260,8 +246,8 @@ const Button* FileSelection::get_ok_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->ok_button));
 }
- 
- Button* FileSelection::get_cancel_button()
+
+Button* FileSelection::get_cancel_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->cancel_button));
 }
@@ -270,8 +256,8 @@ const Button* FileSelection::get_cancel_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->cancel_button));
 }
- 
- Button* FileSelection::get_help_button()
+
+Button* FileSelection::get_help_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->help_button));
 }
@@ -280,8 +266,8 @@ const Button* FileSelection::get_help_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->help_button));
 }
- 
- HButtonBox* FileSelection::get_button_area()
+
+HButtonBox* FileSelection::get_button_area()
 {
   return Glib::wrap((GtkHButtonBox*)(gobj()->button_area));
 }
@@ -290,8 +276,8 @@ const HButtonBox* FileSelection::get_button_area() const
 {
   return Glib::wrap((GtkHButtonBox*)(gobj()->button_area));
 }
- 
- HBox* FileSelection::get_action_area()
+
+HBox* FileSelection::get_action_area()
 {
   return Glib::wrap((GtkHBox*)(gobj()->action_area));
 }
@@ -300,60 +286,39 @@ const HBox* FileSelection::get_action_area() const
 {
   return Glib::wrap((GtkHBox*)(gobj()->action_area));
 }
- 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+
 Glib::PropertyProxy<bool> FileSelection::property_show_fileops() 
 {
   return Glib::PropertyProxy<bool>(this, "show-fileops");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileSelection::property_show_fileops() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "show-fileops");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<std::string> FileSelection::property_filename() 
 {
   return Glib::PropertyProxy<std::string>(this, "filename");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<std::string> FileSelection::property_filename() const
 {
   return Glib::PropertyProxy_ReadOnly<std::string>(this, "filename");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FileSelection::property_select_multiple() 
 {
   return Glib::PropertyProxy<bool>(this, "select-multiple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FileSelection::property_select_multiple() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "select-multiple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
diff --git a/libs/gtkmm2/gtk/gtkmm/fileselection.h b/libs/gtkmm2/gtk/gtkmm/fileselection.h
index 5923b16da0..6a5e734362 100644
--- a/libs/gtkmm2/gtk/gtkmm/fileselection.h
+++ b/libs/gtkmm2/gtk/gtkmm/fileselection.h
@@ -3,9 +3,6 @@
 #ifndef _GTKMM_FILESELECTION_H
 #define _GTKMM_FILESELECTION_H
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -106,17 +103,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -188,40 +179,37 @@ public:
   bool get_select_multiple() const;
 
   //: Accessors
-   TreeView* get_dir_list();
+  TreeView* get_dir_list();
   const TreeView* get_dir_list() const;
-    TreeView* get_file_list();
+  TreeView* get_file_list();
   const TreeView* get_file_list() const;
-    OptionMenu* get_history_pulldown();
+  OptionMenu* get_history_pulldown();
   const OptionMenu* get_history_pulldown() const;
-    Entry* get_selection_entry();
+  Entry* get_selection_entry();
   const Entry* get_selection_entry() const;
-    Label* get_selection_text();
+  Label* get_selection_text();
   const Label* get_selection_text() const;
-    VBox* get_main_vbox();
+  VBox* get_main_vbox();
   const VBox* get_main_vbox() const;
-    Button* get_ok_button();
+  Button* get_ok_button();
   const Button* get_ok_button() const;
-    Button* get_cancel_button();
+  Button* get_cancel_button();
   const Button* get_cancel_button() const;
-    Button* get_help_button();
+  Button* get_help_button();
   const Button* get_help_button() const;
-    HButtonBox* get_button_area();
+  HButtonBox* get_button_area();
   const HButtonBox* get_button_area() const;
-    HBox* get_action_area();
+  HBox* get_action_area();
   const HBox* get_action_area() const;
- 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether buttons for creating/manipulating files should be displayed.
+
+  /** Whether buttons for creating/manipulating files should be displayed.
    *
    * 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_show_fileops() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether buttons for creating/manipulating files should be displayed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -229,19 +217,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_show_fileops() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The currently selected filename.
+  /** The currently selected filename.
    *
    * 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<std::string> property_filename() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The currently selected filename.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -249,19 +233,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<std::string> property_filename() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to allow multiple files to be selected.
+  /** Whether to allow multiple files to be selected.
    *
    * 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_select_multiple() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to allow multiple files to be selected.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -269,11 +249,11 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_select_multiple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
 
+
 } // namespace Gtk
 
 
@@ -285,11 +265,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FileSelection* wrap(GtkFileSelection* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
+}
 #endif /* _GTKMM_FILESELECTION_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/fixed.cc b/libs/gtkmm2/gtk/gtkmm/fixed.cc
index 9b522f3579..9edbae969a 100644
--- a/libs/gtkmm2/gtk/gtkmm/fixed.cc
+++ b/libs/gtkmm2/gtk/gtkmm/fixed.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/fixed.h>
 #include <gtkmm/private/fixed_p.h>
 
@@ -79,19 +78,8 @@ void Fixed_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Fixed_Class::wrap_new(GObject* o)
 {
@@ -141,17 +129,17 @@ Fixed::Fixed()
 
 void Fixed::put(Widget& widget, int x, int y)
 {
-gtk_fixed_put(gobj(), (widget).gobj(), x, y); 
+  gtk_fixed_put(gobj(), (widget).gobj(), x, y);
 }
 
 void Fixed::move(Widget& widget, int x, int y)
 {
-gtk_fixed_move(gobj(), (widget).gobj(), x, y); 
+  gtk_fixed_move(gobj(), (widget).gobj(), x, y);
 }
 
 void Fixed::set_has_window(bool has_window)
 {
-gtk_fixed_set_has_window(gobj(), static_cast<int>(has_window)); 
+  gtk_fixed_set_has_window(gobj(), static_cast<int>(has_window));
 }
 
 bool Fixed::get_has_window() const
@@ -160,13 +148,6 @@ bool Fixed::get_has_window() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/fixed.h b/libs/gtkmm2/gtk/gtkmm/fixed.h
index d0f8eeeb98..c7b334a238 100644
--- a/libs/gtkmm2/gtk/gtkmm/fixed.h
+++ b/libs/gtkmm2/gtk/gtkmm/fixed.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FIXED_H
 #define _GTKMM_FIXED_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -99,17 +98,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -123,13 +116,10 @@ public:
   void move(Widget& widget, int x, int y);
   
   /** Sets whether a Gtk::Fixed widget is created with a separate
-   * Gdk::Window for @a widget -&gt;window or not. (By default, it will be
+   * Gdk::Window for widget->window or not. (By default, it will be
    * created with no separate Gdk::Window). This function must be called
    * while the Gtk::Fixed is not realized, for instance, immediately after the
    * window is created.
-   * 
-   * This function was added to provide an easy migration path for
-   * older applications which may expect Gtk::Fixed to have a separate window.
    * @param has_window <tt>true</tt> if a separate window should be created.
    */
   void set_has_window(bool has_window = true);
@@ -154,8 +144,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Fixed* wrap(GtkFixed* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FIXED_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/fontbutton.cc b/libs/gtkmm2/gtk/gtkmm/fontbutton.cc
index 731ad35b1d..4644534f21 100644
--- a/libs/gtkmm2/gtk/gtkmm/fontbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/fontbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/fontbutton.h>
 #include <gtkmm/private/fontbutton_p.h>
 
@@ -38,15 +37,13 @@ namespace Gtk
 namespace
 {
 
-
-static const Glib::SignalProxyInfo FontButton_signal_font_set_info =
+const Glib::SignalProxyInfo FontButton_signal_font_set_info =
 {
   "font-set",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -91,18 +88,10 @@ void FontButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->font_set = &font_set_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void FontButton_Class::font_set_callback(GtkFontButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -115,19 +104,15 @@ void FontButton_Class::font_set_callback(GtkFontButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_font_set();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -140,7 +125,6 @@ void FontButton_Class::font_set_callback(GtkFontButton* self)
       (*base->font_set)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* FontButton_Class::wrap_new(GObject* o)
@@ -189,10 +173,10 @@ FontButton::FontButton()
 {
   }
 
-FontButton::FontButton(const Glib::ustring& font_name)
+FontButton::FontButton(const Glib::ustring& fontname)
 :
   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Button(Glib::ConstructParams(fontbutton_class_.init(), "font_name", font_name.c_str(), (char*) 0))
+  Gtk::Button(Glib::ConstructParams(fontbutton_class_.init(), "fontname", fontname.c_str(), (char*) 0))
 {
   }
 
@@ -203,7 +187,7 @@ Glib::ustring FontButton::get_title() const
 
 void FontButton::set_title(const Glib::ustring& title)
 {
-gtk_font_button_set_title(gobj(), title.c_str()); 
+  gtk_font_button_set_title(gobj(), title.c_str());
 }
 
 bool FontButton::get_use_font() const
@@ -213,7 +197,7 @@ bool FontButton::get_use_font() const
 
 void FontButton::set_use_font(bool use_font)
 {
-gtk_font_button_set_use_font(gobj(), static_cast<int>(use_font)); 
+  gtk_font_button_set_use_font(gobj(), static_cast<int>(use_font));
 }
 
 bool FontButton::get_use_size() const
@@ -223,7 +207,7 @@ bool FontButton::get_use_size() const
 
 void FontButton::set_use_size(bool use_size)
 {
-gtk_font_button_set_use_size(gobj(), static_cast<int>(use_size)); 
+  gtk_font_button_set_use_size(gobj(), static_cast<int>(use_size));
 }
 
 Glib::ustring FontButton::get_font_name() const
@@ -243,7 +227,7 @@ bool FontButton::get_show_style() const
 
 void FontButton::set_show_style(bool show_style)
 {
-gtk_font_button_set_show_style(gobj(), static_cast<int>(show_style)); 
+  gtk_font_button_set_show_style(gobj(), static_cast<int>(show_style));
 }
 
 bool FontButton::get_show_size() const
@@ -253,7 +237,7 @@ bool FontButton::get_show_size() const
 
 void FontButton::set_show_size(bool show_size)
 {
-gtk_font_button_set_show_size(gobj(), static_cast<int>(show_size)); 
+  gtk_font_button_set_show_size(gobj(), static_cast<int>(show_size));
 }
 
 
@@ -263,92 +247,67 @@ Glib::SignalProxy0< void > FontButton::signal_font_set()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> FontButton::property_title() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> FontButton::property_title() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> FontButton::property_font_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "font-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> FontButton::property_font_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FontButton::property_use_font() 
 {
   return Glib::PropertyProxy<bool>(this, "use-font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FontButton::property_use_font() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FontButton::property_use_size() 
 {
   return Glib::PropertyProxy<bool>(this, "use-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FontButton::property_use_size() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FontButton::property_show_style() 
 {
   return Glib::PropertyProxy<bool>(this, "show-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FontButton::property_show_style() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "show-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> FontButton::property_show_size() 
 {
   return Glib::PropertyProxy<bool>(this, "show-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> FontButton::property_show_size() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "show-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::FontButton::on_font_set()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -358,10 +317,6 @@ void Gtk::FontButton::on_font_set()
   if(base && base->font_set)
     (*base->font_set)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/fontbutton.h b/libs/gtkmm2/gtk/gtkmm/fontbutton.h
index 5ac3bbd8a1..79edaa1d02 100644
--- a/libs/gtkmm2/gtk/gtkmm/fontbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/fontbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FONTBUTTON_H
 #define _GTKMM_FONTBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -92,37 +91,31 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_font_set();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
 
 public:
   FontButton();
-  explicit FontButton(const Glib::ustring& font_name);
+  explicit FontButton(const Glib::ustring& fontname);
   
   
   /** Retrieves the title of the font selection dialog.
    * @return An internal copy of the title string which must not be freed.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_title() const;
   
   /** Sets the title for the font selection dialog.  
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param title A string containing the font selection dialog title.
    */
   void set_title(const Glib::ustring& title);
@@ -130,13 +123,13 @@ public:
   /** Returns whether the selected font is used in the label.
    * @return Whether the selected font is used in the label.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_use_font() const;
   
   /** If @a use_font  is <tt>true</tt>, the font name will be written using the selected font.  
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_font If <tt>true</tt>, font name will be written using font chosen.
    */
   void set_use_font(bool use_font = true);
@@ -144,13 +137,13 @@ public:
   /** Returns whether the selected size is used in the label.
    * @return Whether the selected size is used in the label.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_use_size() const;
   
   /** If @a use_size  is <tt>true</tt>, the font name will be written using the selected size.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_size If <tt>true</tt>, font name will be written using the selected size.
    */
   void set_use_size(bool use_size = true);
@@ -158,7 +151,7 @@ public:
   /** Retrieves the name of the currently selected font.
    * @return An internal copy of the font name which must not be freed.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_font_name() const;
   
@@ -167,20 +160,20 @@ public:
    * @return Return value of Gtk::FontSelectionDialog::set_font_name() if the
    * font selection dialog exists, otherwise <tt>false</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool set_font_name(const Glib::ustring& fontname);
   
   /** Returns whether the name of the font style will be shown in the label.
    * @return Whether the font style will be shown in the label.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_show_style() const;
   
   /** If @a show_style  is <tt>true</tt>, the font style will be displayed along with name of the selected font.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param show_style <tt>true</tt> if font style should be displayed in label.
    */
   void set_show_style(bool show_style = true);
@@ -188,28 +181,25 @@ public:
   /** Returns whether the font size will be shown in the label.
    * @return Whether the font size will be shown in the label.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_show_size() const;
   
   /** If @a show_size  is <tt>true</tt>, the font size will be displayed along with the name of the selected font.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param show_size <tt>true</tt> if font size should be displayed in dialog.
    */
   void set_show_size(bool show_size = true);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The title of the font selection dialog.
+  /** The title of the font selection dialog.
    *
    * 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_title() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The title of the font selection dialog.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -217,19 +207,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The name of the selected font.
+  /** The name of the selected 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<Glib::ustring> property_font_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The name of the selected font.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -237,19 +223,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the label is drawn in the selected font.
+  /** Whether the label is drawn in the selected 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<bool> property_use_font() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the label is drawn in the selected font.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -257,19 +239,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_font() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the label is drawn with the selected font size.
+  /** Whether the label is drawn with the selected font 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<bool> property_use_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the label is drawn with the selected font size.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -277,19 +255,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the selected font style is shown in the label.
+  /** Whether the selected font style is shown in the label.
    *
    * 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_show_style() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the selected font style is shown in the label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -297,19 +271,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_show_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether selected font size is shown in the label.
+  /** Whether selected font size is shown in the label.
    *
    * 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_show_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether selected font size is shown in the label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -317,18 +287,8 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_show_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  /** The font_set signal is emitted when the user selects a font. When handling this signal,
-   * use get_font_name() to find out which font was just selected.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %font_set()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_font_set();
                                              
 
@@ -346,8 +306,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FontButton* wrap(GtkFontButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FONTBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/fontselection.cc b/libs/gtkmm2/gtk/gtkmm/fontselection.cc
index cf9e9799d4..45ccfcee76 100644
--- a/libs/gtkmm2/gtk/gtkmm/fontselection.cc
+++ b/libs/gtkmm2/gtk/gtkmm/fontselection.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/fontselection.h>
 #include <gtkmm/private/fontselection_p.h>
 
@@ -76,19 +75,8 @@ void FontSelection_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FontSelection_Class::wrap_new(GObject* o)
 {
@@ -153,10 +141,10 @@ Glib::ustring FontSelection::get_preview_text() const
 
 void FontSelection::set_preview_text(const Glib::ustring& fontname)
 {
-gtk_font_selection_set_preview_text(gobj(), fontname.c_str()); 
+  gtk_font_selection_set_preview_text(gobj(), fontname.c_str());
 }
 
- Entry* FontSelection::get_font_entry()
+Entry* FontSelection::get_font_entry()
 {
   return Glib::wrap((GtkEntry*)(gobj()->font_entry));
 }
@@ -165,8 +153,8 @@ const Entry* FontSelection::get_font_entry() const
 {
   return Glib::wrap((GtkEntry*)(gobj()->font_entry));
 }
- 
- Entry* FontSelection::get_font_style_entry()
+
+Entry* FontSelection::get_font_style_entry()
 {
   return Glib::wrap((GtkEntry*)(gobj()->font_style_entry));
 }
@@ -175,8 +163,8 @@ const Entry* FontSelection::get_font_style_entry() const
 {
   return Glib::wrap((GtkEntry*)(gobj()->font_style_entry));
 }
- 
- Entry* FontSelection::get_size_entry()
+
+Entry* FontSelection::get_size_entry()
 {
   return Glib::wrap((GtkEntry*)(gobj()->size_entry));
 }
@@ -185,8 +173,8 @@ const Entry* FontSelection::get_size_entry() const
 {
   return Glib::wrap((GtkEntry*)(gobj()->size_entry));
 }
- 
- RadioButton* FontSelection::get_pixels_button()
+
+RadioButton* FontSelection::get_pixels_button()
 {
   return Glib::wrap((GtkRadioButton*)(gobj()->pixels_button));
 }
@@ -195,8 +183,8 @@ const RadioButton* FontSelection::get_pixels_button() const
 {
   return Glib::wrap((GtkRadioButton*)(gobj()->pixels_button));
 }
- 
- RadioButton* FontSelection::get_points_button()
+
+RadioButton* FontSelection::get_points_button()
 {
   return Glib::wrap((GtkRadioButton*)(gobj()->points_button));
 }
@@ -205,8 +193,8 @@ const RadioButton* FontSelection::get_points_button() const
 {
   return Glib::wrap((GtkRadioButton*)(gobj()->points_button));
 }
- 
- Button* FontSelection::get_filter_button()
+
+Button* FontSelection::get_filter_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->filter_button));
 }
@@ -215,8 +203,8 @@ const Button* FontSelection::get_filter_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->filter_button));
 }
- 
- Entry* FontSelection::get_preview_entry()
+
+Entry* FontSelection::get_preview_entry()
 {
   return Glib::wrap((GtkEntry*)(gobj()->preview_entry));
 }
@@ -225,42 +213,27 @@ const Entry* FontSelection::get_preview_entry() const
 {
   return Glib::wrap((GtkEntry*)(gobj()->preview_entry));
 }
- 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+
 Glib::PropertyProxy<Glib::ustring> FontSelection::property_font_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "font-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> FontSelection::property_font_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> FontSelection::property_preview_text() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "preview-text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> FontSelection::property_preview_text() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "preview-text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -307,19 +280,8 @@ void FontSelectionDialog_Class::class_init_function(void* g_class, void* class_d
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FontSelectionDialog_Class::wrap_new(GObject* o)
 {
@@ -390,10 +352,10 @@ Glib::ustring FontSelectionDialog::get_preview_text() const
 
 void FontSelectionDialog::set_preview_text(const Glib::ustring& fontname)
 {
-gtk_font_selection_dialog_set_preview_text(gobj(), fontname.c_str()); 
+  gtk_font_selection_dialog_set_preview_text(gobj(), fontname.c_str());
 }
 
- FontSelection* FontSelectionDialog::get_font_selection()
+FontSelection* FontSelectionDialog::get_font_selection()
 {
   return Glib::wrap((GtkFontSelection*)(gobj()->fontsel));
 }
@@ -402,8 +364,8 @@ const FontSelection* FontSelectionDialog::get_font_selection() const
 {
   return Glib::wrap((GtkFontSelection*)(gobj()->fontsel));
 }
- 
- Button* FontSelectionDialog::get_ok_button()
+
+Button* FontSelectionDialog::get_ok_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->ok_button));
 }
@@ -412,8 +374,8 @@ const Button* FontSelectionDialog::get_ok_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->ok_button));
 }
- 
- Button* FontSelectionDialog::get_apply_button()
+
+Button* FontSelectionDialog::get_apply_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->apply_button));
 }
@@ -422,8 +384,8 @@ const Button* FontSelectionDialog::get_apply_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->apply_button));
 }
- 
- Button* FontSelectionDialog::get_cancel_button()
+
+Button* FontSelectionDialog::get_cancel_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->cancel_button));
 }
@@ -432,13 +394,6 @@ const Button* FontSelectionDialog::get_cancel_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->cancel_button));
 }
- 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/fontselection.h b/libs/gtkmm2/gtk/gtkmm/fontselection.h
index f1afc19017..ae0b9045d6 100644
--- a/libs/gtkmm2/gtk/gtkmm/fontselection.h
+++ b/libs/gtkmm2/gtk/gtkmm/fontselection.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FONTSELECTION_H
 #define _GTKMM_FONTSELECTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -107,17 +106,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -136,34 +129,31 @@ public:
   void set_preview_text(const Glib::ustring& fontname);
 
   // Font page
-   Entry* get_font_entry();
+  Entry* get_font_entry();
   const Entry* get_font_entry() const;
-    Entry* get_font_style_entry();
+  Entry* get_font_style_entry();
   const Entry* get_font_style_entry() const;
-    Entry* get_size_entry();
+  Entry* get_size_entry();
   const Entry* get_size_entry() const;
- 
-   RadioButton* get_pixels_button();
+
+  RadioButton* get_pixels_button();
   const RadioButton* get_pixels_button() const;
-    RadioButton* get_points_button();
+  RadioButton* get_points_button();
   const RadioButton* get_points_button() const;
-    Button* get_filter_button();
+  Button* get_filter_button();
   const Button* get_filter_button() const;
- 
-   Entry* get_preview_entry();
+
+  Entry* get_preview_entry();
   const Entry* get_preview_entry() const;
- 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The X string that represents this font.
+
+  /** The X string that represents this 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<Glib::ustring> property_font_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The X string that represents this font.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -171,19 +161,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The text to display in order to demonstrate the selected font.
+  /** The text to display in order to demonstrate the selected 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<Glib::ustring> property_preview_text() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The text to display in order to demonstrate the selected font.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -191,7 +177,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_preview_text() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -246,17 +231,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -276,15 +255,15 @@ public:
   
   void set_preview_text(const Glib::ustring& fontname);
 
-   FontSelection* get_font_selection();
+  FontSelection* get_font_selection();
   const FontSelection* get_font_selection() const;
-    Button* get_ok_button();
+  Button* get_ok_button();
   const Button* get_ok_button() const;
-    Button* get_apply_button();
+  Button* get_apply_button();
   const Button* get_apply_button() const;
-    Button* get_cancel_button();
+  Button* get_cancel_button();
   const Button* get_cancel_button() const;
- 
+
 
 };
 
@@ -299,9 +278,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FontSelection* wrap(GtkFontSelection* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::FontSelectionDialog
@@ -310,8 +287,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::FontSelectionDialog* wrap(GtkFontSelectionDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FONTSELECTION_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/frame.cc b/libs/gtkmm2/gtk/gtkmm/frame.cc
index 03df181272..d24fa422c7 100644
--- a/libs/gtkmm2/gtk/gtkmm/frame.cc
+++ b/libs/gtkmm2/gtk/gtkmm/frame.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/frame.h>
 #include <gtkmm/private/frame_p.h>
 
@@ -83,15 +82,9 @@ void Frame_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->compute_child_allocation = &compute_child_allocation_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Frame_Class::compute_child_allocation_vfunc_callback(GtkFrame* self, GtkAllocation* allocation)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -104,20 +97,16 @@ void Frame_Class::compute_child_allocation_vfunc_callback(GtkFrame* self, GtkAll
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->compute_child_allocation_vfunc((Allocation&)(Glib::wrap(allocation))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -130,10 +119,6 @@ void Frame_Class::compute_child_allocation_vfunc_callback(GtkFrame* self, GtkAll
       (*base->compute_child_allocation)(self, allocation);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Frame_Class::wrap_new(GObject* o)
@@ -191,7 +176,7 @@ Frame::Frame(const Glib::ustring& label)
 
 void Frame::set_label(const Glib::ustring& label)
 {
-gtk_frame_set_label(gobj(), label.c_str()); 
+  gtk_frame_set_label(gobj(), label.c_str());
 }
 
 Glib::ustring Frame::get_label() const
@@ -201,7 +186,7 @@ Glib::ustring Frame::get_label() const
 
 void Frame::set_label_widget(Widget& label_widget)
 {
-gtk_frame_set_label_widget(gobj(), (label_widget).gobj()); 
+  gtk_frame_set_label_widget(gobj(), (label_widget).gobj());
 }
 
 Widget* Frame::get_label_widget()
@@ -211,27 +196,27 @@ Widget* Frame::get_label_widget()
 
 const Widget* Frame::get_label_widget() const
 {
-  return const_cast<Frame*>(this)->get_label_widget();
+  return Glib::wrap(gtk_frame_get_label_widget(const_cast<GtkFrame*>(gobj())));
 }
 
 void Frame::set_label_align(float xalign, float yalign)
 {
-gtk_frame_set_label_align(gobj(), xalign, yalign); 
+  gtk_frame_set_label_align(gobj(), xalign, yalign);
 }
 
 void Frame::set_label_align(AlignmentEnum xalign, AlignmentEnum yalign)
 {
-gtk_frame_set_label_align(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign)); 
+  gtk_frame_set_label_align(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign));
 }
 
 void Frame::get_label_align(float& xalign, float& yalign) const
 {
-gtk_frame_get_label_align(const_cast<GtkFrame*>(gobj()), &(xalign), &(yalign)); 
+  gtk_frame_get_label_align(const_cast<GtkFrame*>(gobj()), &(xalign), &(yalign));
 }
 
 void Frame::set_shadow_type(ShadowType type)
 {
-gtk_frame_set_shadow_type(gobj(), ((GtkShadowType)(type))); 
+  gtk_frame_set_shadow_type(gobj(), ((GtkShadowType)(type)));
 }
 
 ShadowType Frame::get_shadow_type() const
@@ -240,81 +225,57 @@ ShadowType Frame::get_shadow_type() const
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Frame::property_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Frame::property_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Frame::property_label_xalign() 
 {
   return Glib::PropertyProxy<double>(this, "label-xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Frame::property_label_xalign() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "label-xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Frame::property_label_yalign() 
 {
   return Glib::PropertyProxy<double>(this, "label-yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Frame::property_label_yalign() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "label-yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ShadowType> Frame::property_shadow_type() 
 {
   return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ShadowType> Frame::property_shadow_type() const
 {
   return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Widget*> Frame::property_label_widget() 
 {
   return Glib::PropertyProxy<Widget*>(this, "label-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Widget*> Frame::property_label_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "label-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Gtk::Frame::compute_child_allocation_vfunc(Allocation& allocation) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -324,7 +285,6 @@ void Gtk::Frame::compute_child_allocation_vfunc(Allocation& allocation)
   if(base && base->compute_child_allocation)
     (*base->compute_child_allocation)(gobj(),(GtkAllocation*)(allocation.gobj()));
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/frame.h b/libs/gtkmm2/gtk/gtkmm/frame.h
index d67fab075c..aaac3dd63c 100644
--- a/libs/gtkmm2/gtk/gtkmm/frame.h
+++ b/libs/gtkmm2/gtk/gtkmm/frame.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_FRAME_H
 #define _GTKMM_FRAME_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,17 +95,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -209,17 +202,14 @@ public:
    */
   ShadowType get_shadow_type() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text of the frame's label.
+  /** Text of the frame's label.
    *
    * 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_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text of the frame's label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -227,19 +217,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The horizontal alignment of the label.
+  /** The horizontal alignment of the label.
    *
    * 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_label_xalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The horizontal alignment of the label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -247,19 +233,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_label_xalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The vertical alignment of the label.
+  /** The vertical alignment of the label.
    *
    * 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_label_yalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The vertical alignment of the label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -267,19 +249,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_label_yalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Appearance of the frame border.
+  /** Appearance of the frame border.
    *
    * 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<ShadowType> property_shadow_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Appearance of the frame border.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -287,19 +265,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A widget to display in place of the usual frame label.
+  /** A widget to display in place of the usual frame label.
    *
    * 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<Widget*> property_label_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A widget to display in place of the usual frame label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -307,13 +281,10 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Widget*> property_label_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void compute_child_allocation_vfunc(Allocation& allocation);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void compute_child_allocation_vfunc(Allocation& allocation);
 
 
 };
@@ -329,8 +300,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Frame* wrap(GtkFrame* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_FRAME_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/handlebox.cc b/libs/gtkmm2/gtk/gtkmm/handlebox.cc
index 2e4000b1f7..86c2a0fe9c 100644
--- a/libs/gtkmm2/gtk/gtkmm/handlebox.cc
+++ b/libs/gtkmm2/gtk/gtkmm/handlebox.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/handlebox.h>
 #include <gtkmm/private/handlebox_p.h>
 
@@ -58,8 +57,7 @@ bool HandleBox::shrinks_on_detach() const
 namespace
 {
 
-
-static void HandleBox_signal_child_attached_callback(GtkHandleBox* self, GtkWidget* p0,void* data)
+void HandleBox_signal_child_attached_callback(GtkHandleBox* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -67,24 +65,20 @@ static void HandleBox_signal_child_attached_callback(GtkHandleBox* self, GtkWidg
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo HandleBox_signal_child_attached_info =
+const Glib::SignalProxyInfo HandleBox_signal_child_attached_info =
 {
   "child_attached",
   (GCallback) &HandleBox_signal_child_attached_callback,
@@ -92,7 +86,7 @@ static const Glib::SignalProxyInfo HandleBox_signal_child_attached_info =
 };
 
 
-static void HandleBox_signal_child_detached_callback(GtkHandleBox* self, GtkWidget* p0,void* data)
+void HandleBox_signal_child_detached_callback(GtkHandleBox* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -100,31 +94,26 @@ static void HandleBox_signal_child_detached_callback(GtkHandleBox* self, GtkWidg
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo HandleBox_signal_child_detached_info =
+const Glib::SignalProxyInfo HandleBox_signal_child_detached_info =
 {
   "child_detached",
   (GCallback) &HandleBox_signal_child_detached_callback,
   (GCallback) &HandleBox_signal_child_detached_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -169,19 +158,11 @@ void HandleBox_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->child_attached = &child_attached_callback;
   klass->child_detached = &child_detached_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void HandleBox_Class::child_attached_callback(GtkHandleBox* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -194,20 +175,16 @@ void HandleBox_Class::child_attached_callback(GtkHandleBox* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_child_attached(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -220,6 +197,7 @@ void HandleBox_Class::child_attached_callback(GtkHandleBox* self, GtkWidget* p0)
       (*base->child_attached)(self, p0);
   }
 }
+
 void HandleBox_Class::child_detached_callback(GtkHandleBox* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -232,20 +210,16 @@ void HandleBox_Class::child_detached_callback(GtkHandleBox* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_child_detached(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -258,7 +232,6 @@ void HandleBox_Class::child_detached_callback(GtkHandleBox* self, GtkWidget* p0)
       (*base->child_detached)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* HandleBox_Class::wrap_new(GObject* o)
@@ -309,7 +282,7 @@ HandleBox::HandleBox()
 
 void HandleBox::set_shadow_type(ShadowType type)
 {
-gtk_handle_box_set_shadow_type(gobj(), ((GtkShadowType)(type))); 
+  gtk_handle_box_set_shadow_type(gobj(), ((GtkShadowType)(type)));
 }
 
 ShadowType HandleBox::get_shadow_type() const
@@ -319,7 +292,7 @@ ShadowType HandleBox::get_shadow_type() const
 
 void HandleBox::set_handle_position(PositionType position)
 {
-gtk_handle_box_set_handle_position(gobj(), ((GtkPositionType)(position))); 
+  gtk_handle_box_set_handle_position(gobj(), ((GtkPositionType)(position)));
 }
 
 PositionType HandleBox::get_handle_position() const
@@ -329,7 +302,7 @@ PositionType HandleBox::get_handle_position() const
 
 void HandleBox::set_snap_edge(PositionType edge)
 {
-gtk_handle_box_set_snap_edge(gobj(), ((GtkPositionType)(edge))); 
+  gtk_handle_box_set_snap_edge(gobj(), ((GtkPositionType)(edge)));
 }
 
 PositionType HandleBox::get_snap_edge() const
@@ -337,7 +310,7 @@ PositionType HandleBox::get_snap_edge() const
   return ((PositionType)(gtk_handle_box_get_snap_edge(const_cast<GtkHandleBox*>(gobj()))));
 }
 
- Glib::RefPtr<Gdk::Window> HandleBox::get_bin_window()
+Glib::RefPtr<Gdk::Window> HandleBox::get_bin_window()
 {
   Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->bin_window)));
 
@@ -356,8 +329,8 @@ Glib::RefPtr<const Gdk::Window> HandleBox::get_bin_window() const
 
   return ref_ptr;
 }
- 
- Glib::RefPtr<Gdk::Window> HandleBox::get_float_window()
+
+Glib::RefPtr<Gdk::Window> HandleBox::get_float_window()
 {
   Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->float_window)));
 
@@ -376,64 +349,50 @@ Glib::RefPtr<const Gdk::Window> HandleBox::get_float_window() const
 
   return ref_ptr;
 }
- 
+
 
 Glib::SignalProxy1< void,Widget* > HandleBox::signal_child_attached()
 {
   return Glib::SignalProxy1< void,Widget* >(this, &HandleBox_signal_child_attached_info);
 }
 
-
 Glib::SignalProxy1< void,Widget* > HandleBox::signal_child_detached()
 {
   return Glib::SignalProxy1< void,Widget* >(this, &HandleBox_signal_child_detached_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ShadowType> HandleBox::property_shadow_type() 
 {
   return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ShadowType> HandleBox::property_shadow_type() const
 {
   return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<PositionType> HandleBox::property_handle_position() 
 {
   return Glib::PropertyProxy<PositionType>(this, "handle-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<PositionType> HandleBox::property_handle_position() const
 {
   return Glib::PropertyProxy_ReadOnly<PositionType>(this, "handle-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<PositionType> HandleBox::property_snap_edge() 
 {
   return Glib::PropertyProxy<PositionType>(this, "snap-edge");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<PositionType> HandleBox::property_snap_edge() const
 {
   return Glib::PropertyProxy_ReadOnly<PositionType>(this, "snap-edge");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::HandleBox::on_child_attached(Widget* child)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -443,6 +402,7 @@ void Gtk::HandleBox::on_child_attached(Widget* child)
   if(base && base->child_attached)
     (*base->child_attached)(gobj(),(GtkWidget*)Glib::unwrap(child));
 }
+
 void Gtk::HandleBox::on_child_detached(Widget* child)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -452,10 +412,6 @@ void Gtk::HandleBox::on_child_detached(Widget* child)
   if(base && base->child_detached)
     (*base->child_detached)(gobj(),(GtkWidget*)Glib::unwrap(child));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/handlebox.h b/libs/gtkmm2/gtk/gtkmm/handlebox.h
index fe211425e2..89d4614bfc 100644
--- a/libs/gtkmm2/gtk/gtkmm/handlebox.h
+++ b/libs/gtkmm2/gtk/gtkmm/handlebox.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_HANDLEBOX_H
 #define _GTKMM_HANDLEBOX_H
 
-
 #include <glibmm.h>
 
  /* $Id$ */
@@ -96,19 +95,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_child_attached(Widget* child);
   virtual void on_child_detached(Widget* child);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -143,44 +136,31 @@ public:
   PositionType get_snap_edge() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %child_attached(Widget* child)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget* > signal_child_attached();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %child_detached(Widget* child)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget* > signal_child_detached();
 
 
-   Glib::RefPtr<Gdk::Window> get_bin_window();
+  Glib::RefPtr<Gdk::Window> get_bin_window();
   Glib::RefPtr<const Gdk::Window> get_bin_window() const;
-    Glib::RefPtr<Gdk::Window> get_float_window();
+  Glib::RefPtr<Gdk::Window> get_float_window();
   Glib::RefPtr<const Gdk::Window> get_float_window() const;
- 
+
   bool is_child_detached() const;
   bool is_float_window_mapped() const;
   bool is_in_drag() const;
   bool shrinks_on_detach() const;
 
   //_WRAP_PROPERTY("shadow", ShadowType); //deprecated.
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Appearance of the shadow that surrounds the container.
+  /** Appearance of the shadow that surrounds the container.
    *
    * 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<ShadowType> property_shadow_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Appearance of the shadow that surrounds the container.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -188,19 +168,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Position of the handle relative to the child widget.
+  /** Position of the handle relative to the child 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<PositionType> property_handle_position() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Position of the handle relative to the child widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -208,19 +184,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<PositionType> property_handle_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Side of the handlebox that's lined up with the docking point to dock the handlebox.
+  /** Side of the handlebox that's lined up with the docking point to dock the handlebox.
    *
    * 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<PositionType> property_snap_edge() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Side of the handlebox that's lined up with the docking point to dock the handlebox.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -228,7 +200,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<PositionType> property_snap_edge() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -244,8 +215,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HandleBox* wrap(GtkHandleBox* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_HANDLEBOX_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/iconfactory.cc b/libs/gtkmm2/gtk/gtkmm/iconfactory.cc
index d068b95433..4a305d1291 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconfactory.cc
+++ b/libs/gtkmm2/gtk/gtkmm/iconfactory.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/iconfactory.h>
 #include <gtkmm/private/iconfactory_p.h>
 
@@ -114,19 +113,8 @@ void IconFactory_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* IconFactory_Class::wrap_new(GObject* object)
 {
@@ -182,27 +170,20 @@ Glib::RefPtr<IconFactory> IconFactory::create()
 }
 void IconFactory::add(const Gtk::StockID& stock_id, const IconSet& icon_set)
 {
-gtk_icon_factory_add(gobj(), (stock_id).get_c_str(), const_cast<GtkIconSet*>((icon_set).gobj())); 
+  gtk_icon_factory_add(gobj(), (stock_id).get_c_str(), const_cast<GtkIconSet*>((icon_set).gobj()));
 }
 
 void IconFactory::add_default()
 {
-gtk_icon_factory_add_default(gobj()); 
+  gtk_icon_factory_add_default(gobj());
 }
 
 void IconFactory::remove_default()
 {
-gtk_icon_factory_remove_default(gobj()); 
+  gtk_icon_factory_remove_default(gobj());
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/iconfactory.h b/libs/gtkmm2/gtk/gtkmm/iconfactory.h
index 5b323f1976..39b98e792f 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconfactory.h
+++ b/libs/gtkmm2/gtk/gtkmm/iconfactory.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ICONFACTORY_H
 #define _GTKMM_ICONFACTORY_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -115,11 +114,11 @@ public:
   void add(const Gtk::StockID& stock_id, const IconSet& icon_set);
   
   /** Adds an icon factory to the list of icon factories searched by
-   *     Gtk::Style::lookup_icon_set(). This means that, for example,
-   *     the Image::Image(const Gtk::StockID& stock_id, IconSize size) constructor will be able to find icons in @a factory .
-   *     There will normally be an icon factory added for each library or
-   *     application that comes with icons. The default icon factories
-   *     can be overridden by themes.
+   * Gtk::Style::lookup_icon_set(). This means that, for example,
+   * Gtk::Image::new_from_stock() will be able to find icons in @a factory .
+   * There will normally be an icon factory added for each library or
+   * application that comes with icons. The default icon factories
+   * can be overridden by themes.
    */
   void add_default();
   
@@ -134,17 +133,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/iconinfo.cc b/libs/gtkmm2/gtk/gtkmm/iconinfo.cc
index a5655cd711..7dfaa15c79 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconinfo.cc
+++ b/libs/gtkmm2/gtk/gtkmm/iconinfo.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/iconinfo.h>
 #include <gtkmm/private/iconinfo_p.h>
 
@@ -133,40 +132,33 @@ Glib::RefPtr<Gdk::Pixbuf> IconInfo::get_builtin_pixbuf()
 {
 
   Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_info_get_builtin_pixbuf(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Pixbuf> IconInfo::get_builtin_pixbuf() const
 {
-  return const_cast<IconInfo*>(this)->get_builtin_pixbuf();
-}
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<Gdk::Pixbuf> IconInfo::load_icon() const
-#else
-Glib::RefPtr<Gdk::Pixbuf> IconInfo::load_icon(std::auto_ptr<Glib::Error>& error) const
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_info_load_icon(const_cast<GtkIconInfo*>(gobj()), &(gerror)));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_info_get_builtin_pixbuf(const_cast<GtkIconInfo*>(gobj())));
 
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
+}
 
+Glib::RefPtr<Gdk::Pixbuf> IconInfo::load_icon() const
+{
+  GError *error = 0;
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_info_load_icon(const_cast<GtkIconInfo*>(gobj()), &(error)));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
 }
 
 void IconInfo::set_raw_coordinates(bool raw_coordinates)
 {
-gtk_icon_info_set_raw_coordinates(gobj(), static_cast<int>(raw_coordinates)); 
+  gtk_icon_info_set_raw_coordinates(gobj(), static_cast<int>(raw_coordinates));
 }
 
 bool IconInfo::get_embedded_rect(Gdk::Rectangle& rectangle) const
diff --git a/libs/gtkmm2/gtk/gtkmm/iconinfo.h b/libs/gtkmm2/gtk/gtkmm/iconinfo.h
index 5eadf4f2e8..73f36a2f6f 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconinfo.h
+++ b/libs/gtkmm2/gtk/gtkmm/iconinfo.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ICONINFO_H
 #define _GTKMM_ICONINFO_H
 
-
 #include <glibmm.h>
 
 /* Copyright (C) 2003 The gtkmm Development Team
@@ -90,7 +89,7 @@ public:
    * @return The base size, or 0, if no base
    * size is known for the icon.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_base_size() const;
   
@@ -131,20 +130,14 @@ public:
    * will avoid scaling icons that it considers sufficiently close to the
    * requested size or for which the source image would have to be scaled
    * up too far. (This maintains sharpness.)
-   * @param error Location to store error information on failure, or <tt>0</tt>.
    * @return The rendered icon; this may be a newly created icon
    * or a new reference to an internal icon, so you must not modify
    * the icon. Use Glib::object_unref() to release your reference to the
    * icon.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   Glib::RefPtr<Gdk::Pixbuf> load_icon() const;
-#else
-  Glib::RefPtr<Gdk::Pixbuf> load_icon(std::auto_ptr<Glib::Error>& error) const;
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   
   /** Sets whether the coordinates returned by gtk_icon_info_get_embedded_rect()
    * and gtk_icon_info_get_attach_points() should be returned in their
@@ -161,7 +154,7 @@ public:
    * This function is provided primarily to allow compatibility wrappers
    * for older API's, and is not expected to be useful for applications.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param raw_coordinates Whether the coordinates of embedded rectangles
    * and attached points should be returned in their original
    * (unscaled) form.
@@ -178,7 +171,7 @@ public:
    * when this function returns <tt>true</tt>.
    * @return <tt>true</tt> if the icon has an embedded rectangle
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_embedded_rect(Gdk::Rectangle& rectangle) const;
   bool get_attach_points(Glib::ArrayHandle<Gdk::Point>& points) const;
@@ -190,7 +183,7 @@ public:
    * the icon doesn't have a specified display name. This value
    * is owned @a icon_info  and must not be modified or free.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_display_name() const;
 
@@ -230,6 +223,5 @@ class Value<Gtk::IconInfo> : public Glib::Value_Boxed<Gtk::IconInfo>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_ICONINFO_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/iconset.cc b/libs/gtkmm2/gtk/gtkmm/iconset.cc
index 8610da7c4c..7546b7d7d2 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconset.cc
+++ b/libs/gtkmm2/gtk/gtkmm/iconset.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/iconset.h>
 #include <gtkmm/private/iconset_p.h>
 
@@ -138,7 +137,7 @@ Glib::RefPtr<Gdk::Pixbuf> IconSet::render_icon(const Glib::RefPtr<Style>& style,
 
 void IconSet::add_source(const IconSource& source)
 {
-gtk_icon_set_add_source(gobj(), (source).gobj()); 
+  gtk_icon_set_add_source(gobj(), (source).gobj());
 }
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/iconset.h b/libs/gtkmm2/gtk/gtkmm/iconset.h
index 65ab0b57fa..25ec3756ea 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconset.h
+++ b/libs/gtkmm2/gtk/gtkmm/iconset.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ICONSET_H
 #define _GTKMM_ICONSET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -45,9 +44,6 @@ namespace Gtk
 class Style;
 class Widget;
 
-//TODO_API: Is _CLASS_BOXEDTYPE the appropriate thing to use here.
-//This seems to be reference-counted, not copied.
-
 class IconSet
 {
   public:
@@ -188,6 +184,5 @@ class Value<Gtk::IconSet> : public Glib::Value_Boxed<Gtk::IconSet>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_ICONSET_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/iconsource.cc b/libs/gtkmm2/gtk/gtkmm/iconsource.cc
index 49d86ee5b2..4ff332d9fd 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconsource.cc
+++ b/libs/gtkmm2/gtk/gtkmm/iconsource.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/iconsource.h>
 #include <gtkmm/private/iconsource_p.h>
 
@@ -27,6 +26,7 @@
  */
 
 #include <gtk/gtkiconfactory.h>
+
 namespace
 {
 } // anonymous namespace
@@ -99,12 +99,12 @@ GtkIconSource* IconSource::gobj_copy() const
 
 void IconSource::set_filename(const Glib::ustring& filename)
 {
-gtk_icon_source_set_filename(gobj(), filename.c_str()); 
+  gtk_icon_source_set_filename(gobj(), filename.c_str());
 }
 
 void IconSource::set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
 {
-gtk_icon_source_set_pixbuf(gobj(), Glib::unwrap(pixbuf)); 
+  gtk_icon_source_set_pixbuf(gobj(), Glib::unwrap(pixbuf));
 }
 
 Glib::ustring IconSource::get_filename() const
@@ -116,30 +116,35 @@ Glib::RefPtr<Gdk::Pixbuf> IconSource::get_pixbuf()
 {
 
   Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_source_get_pixbuf(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Pixbuf> IconSource::get_pixbuf() const
 {
-  return const_cast<IconSource*>(this)->get_pixbuf();
+
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_source_get_pixbuf(const_cast<GtkIconSource*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void IconSource::set_direction_wildcarded(bool setting)
 {
-gtk_icon_source_set_direction_wildcarded(gobj(), static_cast<int>(setting)); 
+  gtk_icon_source_set_direction_wildcarded(gobj(), static_cast<int>(setting));
 }
 
 void IconSource::set_state_wildcarded(bool setting)
 {
-gtk_icon_source_set_state_wildcarded(gobj(), static_cast<int>(setting)); 
+  gtk_icon_source_set_state_wildcarded(gobj(), static_cast<int>(setting));
 }
 
 void IconSource::set_size_wildcarded(bool setting)
 {
-gtk_icon_source_set_size_wildcarded(gobj(), static_cast<int>(setting)); 
+  gtk_icon_source_set_size_wildcarded(gobj(), static_cast<int>(setting));
 }
 
 bool IconSource::get_size_wildcarded() const
@@ -159,17 +164,17 @@ bool IconSource::get_direction_wildcarded() const
 
 void IconSource::set_direction(TextDirection direction)
 {
-gtk_icon_source_set_direction(gobj(), ((GtkTextDirection)(direction))); 
+  gtk_icon_source_set_direction(gobj(), ((GtkTextDirection)(direction)));
 }
 
 void IconSource::set_state(Gtk::StateType state)
 {
-gtk_icon_source_set_state(gobj(), ((GtkStateType)(state))); 
+  gtk_icon_source_set_state(gobj(), ((GtkStateType)(state)));
 }
 
 void IconSource::set_size(IconSize size)
 {
-gtk_icon_source_set_size(gobj(), static_cast<GtkIconSize>(int(size))); 
+  gtk_icon_source_set_size(gobj(), static_cast<GtkIconSize>(int(size)));
 }
 
 TextDirection IconSource::get_direction() const
@@ -189,7 +194,7 @@ IconSize IconSource::get_size() const
 
 void IconSource::set_icon_name(const Glib::ustring& icon_name)
 {
-gtk_icon_source_set_icon_name(gobj(), icon_name.c_str()); 
+  gtk_icon_source_set_icon_name(gobj(), icon_name.c_str());
 }
 
 Glib::ustring IconSource::get_icon_name() const
diff --git a/libs/gtkmm2/gtk/gtkmm/iconsource.h b/libs/gtkmm2/gtk/gtkmm/iconsource.h
index 9365b1984b..67622aa2c7 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconsource.h
+++ b/libs/gtkmm2/gtk/gtkmm/iconsource.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ICONSOURCE_H
 #define _GTKMM_ICONSOURCE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -285,6 +284,5 @@ class Value<Gtk::IconSource> : public Glib::Value_Boxed<Gtk::IconSource>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_ICONSOURCE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/icontheme.cc b/libs/gtkmm2/gtk/gtkmm/icontheme.cc
index 281df63663..4403fe61f0 100644
--- a/libs/gtkmm2/gtk/gtkmm/icontheme.cc
+++ b/libs/gtkmm2/gtk/gtkmm/icontheme.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/icontheme.h>
 #include <gtkmm/private/icontheme_p.h>
 
@@ -35,10 +34,10 @@ void IconTheme::set_search_path(const Glib::ArrayHandle<Glib::ustring>& path)
 
 Glib::ArrayHandle<Glib::ustring> IconTheme::get_search_path() const
 {
-  int temp_int = 0;
-  gchar** temp_path = 0;
-  gtk_icon_theme_get_search_path(const_cast<GtkIconTheme*>(gobj()), &temp_path, &temp_int);
-  return Glib::ArrayHandle<Glib::ustring>((const char**) temp_path, temp_int, Glib::OWNERSHIP_DEEP);
+  int* temp_int = 0;
+  gchar*** temp_path = 0;
+  gtk_icon_theme_get_search_path(const_cast<GtkIconTheme*>(gobj()), temp_path, temp_int);
+  return Glib::ArrayHandle<Glib::ustring>((const char**)(*temp_path), *temp_int, Glib::OWNERSHIP_SHALLOW);
 }
 
 Glib::ArrayHandle<int> IconTheme::get_icon_sizes(const Glib::ustring& icon_name) const
@@ -49,11 +48,6 @@ Glib::ArrayHandle<int> IconTheme::get_icon_sizes(const Glib::ustring& icon_name)
   return Glib::ArrayHandle<int>(pArrayInts, Glib::OWNERSHIP_SHALLOW); //TODO: I'm not sure about the ownership. murrayc.
 }
   
-Glib::ListHandle<Glib::ustring> IconTheme::list_icons() const
-{
-  return Glib::ListHandle<Glib::ustring>(gtk_icon_theme_list_icons(const_cast<GtkIconTheme*>(gobj()), 0 /* means all icons according to the C documentation. */ ), Glib::OWNERSHIP_SHALLOW);
-}
-
 
 } // namespace Gtk
 
@@ -61,15 +55,13 @@ Glib::ListHandle<Glib::ustring> IconTheme::list_icons() const
 namespace
 {
 
-
-static const Glib::SignalProxyInfo IconTheme_signal_changed_info =
+const Glib::SignalProxyInfo IconTheme_signal_changed_info =
 {
   "changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -88,18 +80,10 @@ Gtk::IconThemeError::Code Gtk::IconThemeError::code() const
   return static_cast<Code>(Glib::Error::code());
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 void Gtk::IconThemeError::throw_func(GError* gobject)
 {
   throw Gtk::IconThemeError(gobject);
 }
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Gtk::IconThemeError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Gtk::IconThemeError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
 // static
 GType Glib::Value<Gtk::IconThemeError::Code>::value_type()
@@ -151,18 +135,10 @@ void IconTheme_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->changed = &changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void IconTheme_Class::changed_callback(GtkIconTheme* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -175,19 +151,15 @@ void IconTheme_Class::changed_callback(GtkIconTheme* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -200,7 +172,6 @@ void IconTheme_Class::changed_callback(GtkIconTheme* self)
       (*base->changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* IconTheme_Class::wrap_new(GObject* object)
@@ -265,7 +236,6 @@ Glib::RefPtr<IconTheme> IconTheme::get_default()
   return retvalue;
 }
 
-
 Glib::RefPtr<IconTheme> IconTheme::get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen)
 {
 
@@ -276,25 +246,24 @@ Glib::RefPtr<IconTheme> IconTheme::get_for_screen(const Glib::RefPtr<Gdk::Screen
   return retvalue;
 }
 
-
 void IconTheme::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
 {
-gtk_icon_theme_set_screen(gobj(), Glib::unwrap(screen)); 
+  gtk_icon_theme_set_screen(gobj(), Glib::unwrap(screen));
 }
 
 void IconTheme::append_search_path(const Glib::ustring& path)
 {
-gtk_icon_theme_append_search_path(gobj(), path.c_str()); 
+  gtk_icon_theme_append_search_path(gobj(), path.c_str());
 }
 
 void IconTheme::prepend_search_path(const Glib::ustring& path)
 {
-gtk_icon_theme_prepend_search_path(gobj(), path.c_str()); 
+  gtk_icon_theme_prepend_search_path(gobj(), path.c_str());
 }
 
 void IconTheme::set_custom_theme(const Glib::ustring& theme_name)
 {
-gtk_icon_theme_set_custom_theme(gobj(), theme_name.c_str()); 
+  gtk_icon_theme_set_custom_theme(gobj(), theme_name.c_str());
 }
 
 bool IconTheme::has_icon(const Glib::ustring& icon_name) const
@@ -307,24 +276,12 @@ IconInfo IconTheme::lookup_icon(const Glib::ustring& icon_name, int size, IconLo
   return Glib::wrap(gtk_icon_theme_lookup_icon(const_cast<GtkIconTheme*>(gobj()), icon_name.c_str(), size, ((GtkIconLookupFlags)(flags))));
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::RefPtr<Gdk::Pixbuf> IconTheme::load_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags) const
-#else
-Glib::RefPtr<Gdk::Pixbuf> IconTheme::load_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags, std::auto_ptr<Glib::Error>& error) const
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_theme_load_icon(const_cast<GtkIconTheme*>(gobj()), icon_name.c_str(), size, ((GtkIconLookupFlags)(flags)), &(gerror)));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_icon_theme_load_icon(const_cast<GtkIconTheme*>(gobj()), icon_name.c_str(), size, ((GtkIconLookupFlags)(flags)), &(error)));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
 Glib::ListHandle<Glib::ustring> IconTheme::list_icons(const Glib::ustring& context) const
@@ -344,7 +301,7 @@ bool IconTheme::rescan_if_needed()
 
 void IconTheme::add_builtin_icon(const Glib::ustring& icon_name, int size, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
 {
-gtk_icon_theme_add_builtin_icon(icon_name.c_str(), size, Glib::unwrap(pixbuf));
+  gtk_icon_theme_add_builtin_icon(icon_name.c_str(), size, Glib::unwrap(pixbuf));
 }
 
 
@@ -354,7 +311,6 @@ Glib::SignalProxy0< void > IconTheme::signal_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::IconTheme::on_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -364,10 +320,6 @@ void Gtk::IconTheme::on_changed()
   if(base && base->changed)
     (*base->changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/icontheme.h b/libs/gtkmm2/gtk/gtkmm/icontheme.h
index c17f46b828..450ad2f9ea 100644
--- a/libs/gtkmm2/gtk/gtkmm/icontheme.h
+++ b/libs/gtkmm2/gtk/gtkmm/icontheme.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ICONTHEME_H
 #define _GTKMM_ICONTHEME_H
 
-
 #include <glibmm.h>
 
 /* Copyright (C) 2003 The gtkmm Development Team
@@ -106,14 +105,7 @@ public:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   friend void wrap_init(); // uses throw_func()
 #endif
 };
@@ -196,9 +188,9 @@ public:
    * @return A unique Gtk::IconTheme associated with
    * the default screen. This icon theme is associated with
    * the screen and can be used as long as the screen
-   * is open. Do not ref or unref it.
+   * is open.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   static Glib::RefPtr<IconTheme> get_default();
   
@@ -214,9 +206,9 @@ public:
    * @return A unique Gtk::IconTheme associated with
    * the given screen. This icon theme is associated with
    * the screen and can be used as long as the screen
-   * is open. Do not ref or unref it.
+   * is open.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   static Glib::RefPtr<IconTheme> get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen);
   
@@ -224,7 +216,7 @@ public:
    * to track the user's currently configured icon theme,
    * which might be different for different screens.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param screen A Gdk::Screen.
    */
   void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
@@ -234,7 +226,7 @@ public:
   /** Appends a directory to the search path. 
    * See set_search_path(). 
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param path Directory name to append to the icon path.
    */
   void append_search_path(const Glib::ustring& path);
@@ -242,7 +234,7 @@ public:
   /** Prepends a directory to the search path. 
    * See set_search_path().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param path Directory name to prepend to the icon path.
    */
   void prepend_search_path(const Glib::ustring& path);
@@ -250,11 +242,10 @@ public:
   /** Sets the name of the icon theme that the Gtk::IconTheme object uses
    * overriding system configuration. This function cannot be called
    * on the icon theme objects returned from get_default()
-   * and get_for_screen().
+   * and get_default().
    * 
-   * @newin2p4
-   * @param theme_name Name of icon theme to use instead of configured theme,
-   * or <tt>0</tt> to unset a previously set custom theme.
+   * Since: 2.4
+   * @param theme_name Name of icon theme to use instead of configured theme.
    */
   void set_custom_theme(const Glib::ustring& theme_name);
   
@@ -264,13 +255,13 @@ public:
    * @return <tt>true</tt> if @a icon_theme  includes an
    * icon for @a icon_name .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool has_icon(const Glib::ustring& icon_name) const;
 
   Glib::ArrayHandle<int> get_icon_sizes(const Glib::ustring& icon_name) const;
   
-
+  
 //TODO: Update the docs for this, to suggest use of IconInfo::operator bool() instead of saying that it returns null.
   
   /** Looks up a named icon and returns a structure containing
@@ -285,7 +276,7 @@ public:
    * about the icon, or <tt>0</tt> if the icon wasn't found. Free with
    * gtk_icon_info_free()
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   IconInfo lookup_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags) const;
 
@@ -294,14 +285,6 @@ public:
    * and renders it into a pixbuf. This is a convenience function;
    * if more details about the icon are needed, use
    * lookup_icon() followed by gtk_icon_info_load_icon().
-   * 
-   * Note that you probably want to listen for icon theme changes and
-   * update the icon. This is usually done by connecting to the 
-   * GtkWidget::style-set signal. If for some reason you do not want to
-   * update the icon when the icon theme changes, you should consider
-   * using gdk_pixbuf_copy() to make a private copy of the pixbuf
-   * returned by this function. Otherwise GTK+ may need to keep the old 
-   * icon theme loaded, which would be a waste of memory.
    * @param icon_name The name of the icon to lookup.
    * @param size The desired icon size. The resulting icon may not be exactly this size; see gtk_icon_info_load_icon().
    * @param flags Flags modifying the behavior of the icon lookup.
@@ -310,36 +293,26 @@ public:
    * the icon. Use Glib::object_unref() to release your reference to the
    * icon. <tt>0</tt> if the icon isn't found.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   Glib::RefPtr<Gdk::Pixbuf> load_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags) const;
-#else
-  Glib::RefPtr<Gdk::Pixbuf> load_icon(const Glib::ustring& icon_name, int size, IconLookupFlags flags, std::auto_ptr<Glib::Error>& error) const;
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 
-
-  /** Lists a subset of icons in the current icon theme, by providing a context string.
+  
+  /** Lists the icons in the current icon theme. Only a subset
+   * of the icons can be listed by providing a context string.
    * The set of values for the context string is system dependent,
-   * but will typically include such values as 'Applications' and
-   * 'MimeTypes'.
-   * @param context A string identifying a particular type of icon.
-   * @return The names of all the
-   * icons in the theme.
+   * but will typically include such values as 'apps' and
+   * 'mimetypes'.
+   * @param context A string identifying a particular type of icon,
+   * or <tt>0</tt> to list all icons.
+   * @return A G::List list holding the names of all the
+   * icons in the theme. You must first free each element
+   * in the list with Glib::free(), then free the list itself
+   * with Glib::list_free().
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ListHandle<Glib::ustring> list_icons(const Glib::ustring& context) const;
-
-  /** Lists the icons in the current icon theme.
-   *
-   * @return A list holding the names of all the
-   * icons in the theme.
-   * 
-   * @newin2p10.
-   */
-   Glib::ListHandle<Glib::ustring> list_icons() const;
-
   
   /** Gets the name of an icon that is representative of the
    * current theme (for instance, to use when presenting
@@ -347,7 +320,7 @@ public:
    * @return The name of an example icon or <tt>0</tt>.
    * Free with Glib::free().
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_example_icon_name() const;
   
@@ -357,7 +330,7 @@ public:
    * @return <tt>true</tt> if the icon theme has changed and needed
    * to be reloaded.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool rescan_if_needed();
   
@@ -375,7 +348,7 @@ public:
    * This function will generally be used with pixbufs loaded
    * via gdk_pixbuf_new_from_inline().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param icon_name The name of the icon to register.
    * @param size The size at which to register the icon (different
    * images can be registered for the same icon name
@@ -386,11 +359,6 @@ public:
   static void add_builtin_icon(const Glib::ustring& icon_name, int size, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_changed();
 
 
@@ -398,18 +366,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/iconview.cc b/libs/gtkmm2/gtk/gtkmm/iconview.cc
index 82d3901f94..a053eae250 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconview.cc
+++ b/libs/gtkmm2/gtk/gtkmm/iconview.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/iconview.h>
 #include <gtkmm/private/iconview_p.h>
 
@@ -30,23 +29,19 @@
 namespace //anonymous namespace
 {
 
-static void proxy_foreach_callback(GtkIconView* /* icon_view */, GtkTreePath* path, void* data)
+void proxy_foreach_callback(GtkIconView* /* icon_view */, GtkTreePath* path, void* data)
 {
   typedef Gtk::IconView::SlotForeach SlotType;
   SlotType& slot = *static_cast<SlotType*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     slot(Gtk::TreeModel::Path(path, true));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 } //anonymous namespace
@@ -63,135 +58,7 @@ void IconView::selected_foreach(const SlotForeach& slot)
   SlotForeach slot_copy(slot);
   gtk_icon_view_selected_foreach(const_cast<GtkIconView*>(gobj()), &proxy_foreach_callback, &slot_copy);
 }
-
-bool IconView::get_item_at_pos(int x, int y, TreeModel::Path& path, CellRenderer*& cell) const
-{
-  GtkTreePath* cpath = 0;
-  GtkCellRenderer* ccell = 0;
-  bool result = gtk_icon_view_get_item_at_pos(const_cast<GtkIconView*>(gobj()), x, y, &cpath, &ccell);
-
-  path = Glib::wrap(cpath); //Don't take copy because the gtk_icon_view_get_item_at_pos documentation says we should free this.
-  cell = Glib::wrap(ccell);
-  return result;
-}
-
-bool IconView::get_item_at_pos(int x, int y, TreeModel::Path& path) const
-{
-  GtkTreePath* cpath = 0;
-  bool result = gtk_icon_view_get_item_at_pos(const_cast<GtkIconView*>(gobj()), x, y, &cpath, 0);
-
-  path = Glib::wrap(cpath); //Don't take copy because the gtk_icon_view_get_item_at_pos documentation says we should free this.
-  return result;
-}
-
-bool IconView::get_item_at_pos(int x, int y, CellRenderer*& cell) const
-{
-  GtkCellRenderer* ccell = 0;
-  bool result = gtk_icon_view_get_item_at_pos(const_cast<GtkIconView*>(gobj()), x, y, 0, &ccell);
-
-  cell = Glib::wrap(ccell);
-  return result;
-}
-
-bool IconView::get_visible_range(TreeModel::Path& start_path, TreeModel::Path& end_path) const
-{
-  GtkTreePath* cstart_path = 0;
-  GtkTreePath* cend_path = 0;
-  bool result = gtk_icon_view_get_visible_range(const_cast<GtkIconView*>(gobj()), &cstart_path, &cend_path);
-
-  start_path = Glib::wrap(cstart_path); //Don't take copy because the gtk_icon_view_get_visible_range documentation says we should free this.
-  end_path = Glib::wrap(cend_path); //Don't take copy because the gtk_icon_view_get_visible_range documentation says we should free this.
-  return result;
-}
-
   
-bool IconView::get_cursor(TreeModel::Path& path, CellRenderer*& cell) const
-{
-  GtkTreePath* cpath = 0;
-  GtkCellRenderer* ccell = 0;
-  bool result = gtk_icon_view_get_cursor(const_cast<GtkIconView*>(gobj()), &cpath, &ccell);
-
-  path = Glib::wrap(cpath); //Don't take copy because the gtk_icon_view_get_cursor documentation says we should free this.
-  cell = Glib::wrap(ccell);
-  return result;
-}
-
-bool IconView::get_cursor(TreeModel::Path& path) const
-{
-  GtkTreePath* cpath = 0;
-  bool result = gtk_icon_view_get_cursor(const_cast<GtkIconView*>(gobj()), &cpath, 0);
-
-  path = Glib::wrap(cpath); //Don't take copy because the gtk_icon_view_get_cursor documentation says we should free this.
-  return result;
-}
-
-bool IconView::get_cursor(CellRenderer*& cell) const
-{
-  GtkCellRenderer* ccell = 0;
-  bool result = gtk_icon_view_get_cursor(const_cast<GtkIconView*>(gobj()), 0, &ccell);
-
-  cell = Glib::wrap(ccell);
-  return result;
-}
-
-void IconView::get_drag_dest_item(TreeModel::Path& path, IconViewDropPosition& pos) const
-{
-  GtkTreePath* cpath = 0;
-  gtk_icon_view_get_drag_dest_item(const_cast<GtkIconView*>(gobj()), &cpath, (GtkIconViewDropPosition*)(&pos));
-  if(cpath)
-    path = Gtk::TreeModel::Path(cpath, true /* make_a_copy */);
-}
-
-void IconView::get_drag_dest_item(TreeModel::Path& path) const
-{
-  GtkTreePath* cpath = 0;
-  gtk_icon_view_get_drag_dest_item(const_cast<GtkIconView*>(gobj()), &cpath, NULL);
-  if(cpath)
-    path = Gtk::TreeModel::Path(cpath, true /* make_a_copy */);
-}
-
-void IconView::get_drag_dest_item(IconViewDropPosition& pos) const
-{
-   gtk_icon_view_get_drag_dest_item(const_cast<GtkIconView*>(gobj()), NULL, (GtkIconViewDropPosition*)(&pos));
-}
-
-
-bool IconView::get_dest_item_at_pos(int drag_x, int drag_y, TreeModel::Path& path, IconViewDropPosition& pos) const
-{
-  GtkTreePath* cpath = 0;
-  const bool result = gtk_icon_view_get_dest_item_at_pos(const_cast<GtkIconView*>(gobj()), drag_x, drag_y, &cpath, (GtkIconViewDropPosition*)(&pos));
-  if(cpath)
-    path = Gtk::TreeModel::Path(cpath, true /* make_a_copy */);
-
-  return result;
-}
-
-bool IconView::get_dest_item_at_pos(int drag_x, int drag_y, TreeModel::Path& path) const
-{
-  GtkTreePath* cpath = 0;
-  const bool result = gtk_icon_view_get_dest_item_at_pos(const_cast<GtkIconView*>(gobj()), drag_x, drag_y, &cpath, NULL);
-  if(cpath)
-    path = Gtk::TreeModel::Path(cpath, true /* make_a_copy */);
-
-  return result;
-}
-
-bool IconView::get_dest_item_at_pos(int drag_x, int drag_y, IconViewDropPosition& pos) const
-{
-  return gtk_icon_view_get_dest_item_at_pos(const_cast<GtkIconView*>(gobj()), drag_x, drag_y, NULL, (GtkIconViewDropPosition*)(&pos));
-}
-
-
-void IconView::enable_model_drag_source(const ArrayHandle_TargetEntry& targets, Gdk::ModifierType start_button_mask, Gdk::DragAction actions)
-{
-  gtk_icon_view_enable_model_drag_source(gobj(), (GdkModifierType)start_button_mask, targets.data(), targets.size(), (GdkDragAction)actions);
-}
-
-
-void  IconView::enable_model_drag_dest(const ArrayHandle_TargetEntry& targets, Gdk::DragAction actions)
-{
-  gtk_icon_view_enable_model_drag_dest(gobj(), targets.data(), targets.size(), (GdkDragAction)actions);
-}
 
 } // namespace Gtk
 
@@ -199,8 +66,7 @@ void  IconView::enable_model_drag_dest(const ArrayHandle_TargetEntry& targets, G
 namespace
 {
 
-
-static void IconView_signal_set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+void IconView_signal_set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
@@ -208,25 +74,21 @@ static void IconView_signal_set_scroll_adjustments_callback(GtkIconView* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo IconView_signal_set_scroll_adjustments_info =
+const Glib::SignalProxyInfo IconView_signal_set_scroll_adjustments_info =
 {
   "set_scroll_adjustments",
   (GCallback) &IconView_signal_set_scroll_adjustments_callback,
@@ -234,7 +96,7 @@ static const Glib::SignalProxyInfo IconView_signal_set_scroll_adjustments_info =
 };
 
 
-static void IconView_signal_item_activated_callback(GtkIconView* self, GtkTreePath* p0,void* data)
+void IconView_signal_item_activated_callback(GtkIconView* self, GtkTreePath* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::Path& > SlotType;
@@ -242,24 +104,20 @@ static void IconView_signal_item_activated_callback(GtkIconView* self, GtkTreePa
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Gtk::TreePath(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo IconView_signal_item_activated_info =
+const Glib::SignalProxyInfo IconView_signal_item_activated_info =
 {
   "item_activated",
   (GCallback) &IconView_signal_item_activated_callback,
@@ -267,22 +125,15 @@ static const Glib::SignalProxyInfo IconView_signal_item_activated_info =
 };
 
 
-static const Glib::SignalProxyInfo IconView_signal_selection_changed_info =
+const Glib::SignalProxyInfo IconView_signal_selection_changed_info =
 {
   "selection_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
-// static
-GType Glib::Value<Gtk::IconViewDropPosition>::value_type()
-{
-  return gtk_icon_view_drop_position_get_type();
-}
-
 
 namespace Glib
 {
@@ -325,20 +176,12 @@ void IconView_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
   klass->item_activated = &item_activated_callback;
   klass->selection_changed = &selection_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void IconView_Class::set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0, GtkAdjustment* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -351,21 +194,17 @@ void IconView_Class::set_scroll_adjustments_callback(GtkIconView* self, GtkAdjus
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_scroll_adjustments(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -378,6 +217,7 @@ void IconView_Class::set_scroll_adjustments_callback(GtkIconView* self, GtkAdjus
       (*base->set_scroll_adjustments)(self, p0, p1);
   }
 }
+
 void IconView_Class::item_activated_callback(GtkIconView* self, GtkTreePath* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -390,20 +230,16 @@ void IconView_Class::item_activated_callback(GtkIconView* self, GtkTreePath* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_item_activated(Gtk::TreePath(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -416,6 +252,7 @@ void IconView_Class::item_activated_callback(GtkIconView* self, GtkTreePath* p0)
       (*base->item_activated)(self, p0);
   }
 }
+
 void IconView_Class::selection_changed_callback(GtkIconView* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -428,19 +265,15 @@ void IconView_Class::selection_changed_callback(GtkIconView* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_selection_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -453,7 +286,6 @@ void IconView_Class::selection_changed_callback(GtkIconView* self)
       (*base->selection_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* IconView_Class::wrap_new(GObject* o)
@@ -511,7 +343,7 @@ IconView::IconView(const Glib::RefPtr<TreeModel>& model)
 
 void IconView::set_model(const Glib::RefPtr<TreeModel>& model)
 {
-gtk_icon_view_set_model(gobj(), Glib::unwrap(model)); 
+  gtk_icon_view_set_model(gobj(), Glib::unwrap(model));
 }
 
 Glib::RefPtr<TreeModel> IconView::get_model()
@@ -521,17 +353,17 @@ Glib::RefPtr<TreeModel> IconView::get_model()
 
 Glib::RefPtr<const TreeModel> IconView::get_model() const
 {
-  return const_cast<IconView*>(this)->get_model();
+  return Glib::wrap(gtk_icon_view_get_model(const_cast<GtkIconView*>(gobj())));
 }
 
 void IconView::set_text_column(int column)
 {
-gtk_icon_view_set_text_column(gobj(), column); 
+  gtk_icon_view_set_text_column(gobj(), column);
 }
 
 void IconView::set_text_column(const TreeModelColumnBase& model_column)
 {
-gtk_icon_view_set_text_column(gobj(), (model_column).index()); 
+  gtk_icon_view_set_text_column(gobj(), (model_column).index());
 }
 
 int IconView::get_text_column() const
@@ -541,12 +373,12 @@ int IconView::get_text_column() const
 
 void IconView::set_markup_column(int column)
 {
-gtk_icon_view_set_markup_column(gobj(), column); 
+  gtk_icon_view_set_markup_column(gobj(), column);
 }
 
 void IconView::set_markup_column(const TreeModelColumnBase& column)
 {
-gtk_icon_view_set_markup_column(gobj(), (column).index()); 
+  gtk_icon_view_set_markup_column(gobj(), (column).index());
 }
 
 int IconView::get_markup_column() const
@@ -556,12 +388,12 @@ int IconView::get_markup_column() const
 
 void IconView::set_pixbuf_column(int column)
 {
-gtk_icon_view_set_pixbuf_column(gobj(), column); 
+  gtk_icon_view_set_pixbuf_column(gobj(), column);
 }
 
 void IconView::set_pixbuf_column(const TreeModelColumnBase& column)
 {
-gtk_icon_view_set_pixbuf_column(gobj(), (column).index()); 
+  gtk_icon_view_set_pixbuf_column(gobj(), (column).index());
 }
 
 int IconView::get_pixbuf_column() const
@@ -571,7 +403,7 @@ int IconView::get_pixbuf_column() const
 
 void IconView::set_orientation(Orientation orientation)
 {
-gtk_icon_view_set_orientation(gobj(), ((GtkOrientation)(orientation))); 
+  gtk_icon_view_set_orientation(gobj(), ((GtkOrientation)(orientation)));
 }
 
 Orientation IconView::get_orientation() const
@@ -581,7 +413,7 @@ Orientation IconView::get_orientation() const
 
 void IconView::set_columns(int columns)
 {
-gtk_icon_view_set_columns(gobj(), columns); 
+  gtk_icon_view_set_columns(gobj(), columns);
 }
 
 int IconView::get_columns() const
@@ -591,7 +423,7 @@ int IconView::get_columns() const
 
 void IconView::set_item_width(int item_width)
 {
-gtk_icon_view_set_item_width(gobj(), item_width); 
+  gtk_icon_view_set_item_width(gobj(), item_width);
 }
 
 int IconView::get_icon_width() const
@@ -601,7 +433,7 @@ int IconView::get_icon_width() const
 
 void IconView::set_spacing(int spacing)
 {
-gtk_icon_view_set_spacing(gobj(), spacing); 
+  gtk_icon_view_set_spacing(gobj(), spacing);
 }
 
 int IconView::get_spacing() const
@@ -611,7 +443,7 @@ int IconView::get_spacing() const
 
 void IconView::set_row_spacing(int row_spacing)
 {
-gtk_icon_view_set_row_spacing(gobj(), row_spacing); 
+  gtk_icon_view_set_row_spacing(gobj(), row_spacing);
 }
 
 gint IconView::get_row_spacing() const
@@ -621,7 +453,7 @@ gint IconView::get_row_spacing() const
 
 void IconView::set_column_spacing(int column_spacing)
 {
-gtk_icon_view_set_column_spacing(gobj(), column_spacing); 
+  gtk_icon_view_set_column_spacing(gobj(), column_spacing);
 }
 
 int IconView::get_column_spacing() const
@@ -631,7 +463,7 @@ int IconView::get_column_spacing() const
 
 void IconView::set_margin(int margin)
 {
-gtk_icon_view_set_margin(gobj(), margin); 
+  gtk_icon_view_set_margin(gobj(), margin);
 }
 
 int IconView::get_margin() const
@@ -646,7 +478,7 @@ TreeModel::Path IconView::get_path_at_pos(int x, int y) const
 
 void IconView::set_selection_mode(SelectionMode mode)
 {
-gtk_icon_view_set_selection_mode(gobj(), ((GtkSelectionMode)(mode))); 
+  gtk_icon_view_set_selection_mode(gobj(), ((GtkSelectionMode)(mode)));
 }
 
 SelectionMode IconView::get_selection_mode() const
@@ -656,12 +488,12 @@ SelectionMode IconView::get_selection_mode() const
 
 void IconView::select_path(const TreeModel::Path& path)
 {
-gtk_icon_view_select_path(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
+  gtk_icon_view_select_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 void IconView::unselect_path(const TreeModel::Path& path)
 {
-gtk_icon_view_unselect_path(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
+  gtk_icon_view_unselect_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 bool IconView::path_is_selected(const TreeModel::Path& path) const
@@ -676,52 +508,17 @@ ArrayHandle_TreePaths IconView::get_selected_items() const
 
 void IconView::select_all()
 {
-gtk_icon_view_select_all(gobj()); 
+  gtk_icon_view_select_all(gobj());
 }
 
 void IconView::unselect_all()
 {
-gtk_icon_view_unselect_all(gobj()); 
+  gtk_icon_view_unselect_all(gobj());
 }
 
 void IconView::item_activated(const TreeModel::Path& path)
 {
-gtk_icon_view_item_activated(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
-}
-
-void IconView::scroll_to_path(const TreeModel::Path& path, bool use_align, gfloat row_align, gfloat col_align)
-{
-gtk_icon_view_scroll_to_path(gobj(), const_cast<GtkTreePath*>((path).gobj()), static_cast<int>(use_align), row_align, col_align); 
-}
-
-void IconView::unset_model_drag_source()
-{
-gtk_icon_view_unset_model_drag_source(gobj()); 
-}
-
-void IconView::unset_model_drag_dest()
-{
-gtk_icon_view_unset_model_drag_dest(gobj()); 
-}
-
-void IconView::set_reorderable(bool reorderable)
-{
-gtk_icon_view_set_reorderable(gobj(), static_cast<int>(reorderable)); 
-}
-
-bool IconView::get_reorderable() const
-{
-  return gtk_icon_view_get_reorderable(const_cast<GtkIconView*>(gobj()));
-}
-
-void IconView::set_drag_dest_item(const TreeModel::Path& path, IconViewDropPosition pos)
-{
-gtk_icon_view_set_drag_dest_item(gobj(), const_cast<GtkTreePath*>((path).gobj()), ((GtkIconViewDropPosition)(pos))); 
-}
-
-Glib::RefPtr<Gdk::Pixmap> IconView::create_drag_icon(const TreeModel::Path& path)
-{
-  return Glib::wrap((GdkPixmapObject*)(gtk_icon_view_create_drag_icon(gobj(), const_cast<GtkTreePath*>((path).gobj()))));
+  gtk_icon_view_item_activated(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 
@@ -730,189 +527,138 @@ Glib::SignalProxy2< void,Adjustment*,Adjustment* > IconView::signal_set_scroll_a
   return Glib::SignalProxy2< void,Adjustment*,Adjustment* >(this, &IconView_signal_set_scroll_adjustments_info);
 }
 
-
 Glib::SignalProxy1< void,const TreeModel::Path& > IconView::signal_item_activated()
 {
   return Glib::SignalProxy1< void,const TreeModel::Path& >(this, &IconView_signal_item_activated_info);
 }
 
-
 Glib::SignalProxy0< void > IconView::signal_selection_changed()
 {
   return Glib::SignalProxy0< void >(this, &IconView_signal_selection_changed_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_pixbuf_column() 
 {
   return Glib::PropertyProxy<int>(this, "pixbuf-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_pixbuf_column() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixbuf-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_text_column() 
 {
   return Glib::PropertyProxy<int>(this, "text-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_text_column() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "text-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_markup_column() 
 {
   return Glib::PropertyProxy<int>(this, "markup-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_markup_column() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "markup-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<SelectionMode> IconView::property_selection_mode() 
 {
   return Glib::PropertyProxy<SelectionMode>(this, "selection-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<SelectionMode> IconView::property_selection_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<SelectionMode>(this, "selection-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Orientation> IconView::property_orientation() 
 {
   return Glib::PropertyProxy<Orientation>(this, "orientation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Orientation> IconView::property_orientation() const
 {
   return Glib::PropertyProxy_ReadOnly<Orientation>(this, "orientation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<TreeModel> > IconView::property_model() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > IconView::property_model() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_columns() 
 {
   return Glib::PropertyProxy<int>(this, "columns");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_columns() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "columns");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_item_width() 
 {
   return Glib::PropertyProxy<int>(this, "item-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_item_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "item-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_spacing() 
 {
   return Glib::PropertyProxy<int>(this, "spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_spacing() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_row_spacing() 
 {
   return Glib::PropertyProxy<int>(this, "row-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_row_spacing() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "row-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_column_spacing() 
 {
   return Glib::PropertyProxy<int>(this, "column-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_column_spacing() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "column-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> IconView::property_margin() 
 {
   return Glib::PropertyProxy<int>(this, "margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> IconView::property_margin() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::IconView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -922,6 +668,7 @@ void Gtk::IconView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustmen
   if(base && base->set_scroll_adjustments)
     (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
 }
+
 void Gtk::IconView::on_item_activated(const TreeModel::Path& path)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -931,6 +678,7 @@ void Gtk::IconView::on_item_activated(const TreeModel::Path& path)
   if(base && base->item_activated)
     (*base->item_activated)(gobj(),const_cast<GtkTreePath*>((path).gobj()));
 }
+
 void Gtk::IconView::on_selection_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -940,10 +688,6 @@ void Gtk::IconView::on_selection_changed()
   if(base && base->selection_changed)
     (*base->selection_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/iconview.h b/libs/gtkmm2/gtk/gtkmm/iconview.h
index 54539e3046..26fc442662 100644
--- a/libs/gtkmm2/gtk/gtkmm/iconview.h
+++ b/libs/gtkmm2/gtk/gtkmm/iconview.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ICONVIEW_H
 #define _GTKMM_ICONVIEW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -31,7 +30,6 @@
 #include <gtkmm/container.h>
 #include <gtkmm/treemodel.h>
 #include <gtkmm/treepath.h>
-#include <gtkmm/cellrenderer.h>
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -45,51 +43,7 @@ namespace Gtk
 namespace Gtk
 {
 
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- */
-enum IconViewDropPosition
-{
-  ICON_VIEW_NO_DROP,
-  ICON_VIEW_DROP_INTO,
-  ICON_VIEW_DROP_LEFT,
-  ICON_VIEW_DROP_RIGHT,
-  ICON_VIEW_DROP_ABOVE,
-  ICON_VIEW_DROP_BELOW
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::IconViewDropPosition> : public Glib::Value_Enum<Gtk::IconViewDropPosition>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-//TODO: This should derive+implement from CellLayout when we can break ABI.
-
-/** The IconView provides an alternative view of a list model.
- * It displays the model as a grid of icons with labels. 
- * Like the TreeView, it allows the user to select one or multiple items 
- * (depending on the selection mode - see set_selection_mode()).
- * In addition to selection with the arrow keys, the IconView supports
- * rubberband selection, by dragging the pointer.
+/** TODO
  *
  * @ingroup Widgets
  * @ingroup Containers
@@ -138,20 +92,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment);
   virtual void on_item_activated(const TreeModel::Path& path);
   virtual void on_selection_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -167,7 +115,7 @@ public:
    * it before setting the new model.  If @a model  is <tt>0</tt>, then
    * it will unset the old model.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param model The model.
    */
   void set_model(const Glib::RefPtr<TreeModel>& model);
@@ -176,7 +124,7 @@ public:
    * model is unset.
    * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<TreeModel> get_model();
   
@@ -184,7 +132,7 @@ public:
    * model is unset.
    * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<const TreeModel> get_model() const;
 
@@ -192,7 +140,7 @@ public:
   /** Sets the column with text for @a icon_view  to be @a column . The text
    * column must be of type G::TYPE_STRING.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param column A column in the currently used model.
    */
   void set_text_column(int column);
@@ -200,7 +148,7 @@ public:
   /** Sets the column with text for @a icon_view  to be @a column . The text
    * column must be of type G::TYPE_STRING.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param column A column in the currently used model.
    */
   void set_text_column(const TreeModelColumnBase& model_column);
@@ -208,7 +156,7 @@ public:
   /** Returns the column with text for @a icon_view .
    * @return The text column, or -1 if it's unset.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_text_column() const;
   
@@ -217,7 +165,7 @@ public:
    * If the markup column is set to something, it overrides
    * the text column set by set_text_column().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param column A column in the currently used model.
    */
   void set_markup_column(int column);
@@ -227,7 +175,7 @@ public:
    * If the markup column is set to something, it overrides
    * the text column set by set_text_column().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param column A column in the currently used model.
    */
   void set_markup_column(const TreeModelColumnBase& column); 
@@ -235,14 +183,14 @@ public:
   /** Returns the column with markup text for @a icon_view .
    * @return The markup column, or -1 if it's unset.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_markup_column() const;
   
   /** Sets the column with pixbufs for @a icon_view  to be @a column . The pixbuf
    * column must be of type Gdk::TYPE_PIXBUF
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param column A column in the currently used model.
    */
   void set_pixbuf_column(int column);
@@ -250,7 +198,7 @@ public:
   /** Sets the column with pixbufs for @a icon_view  to be @a column . The pixbuf
    * column must be of type Gdk::TYPE_PIXBUF
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param column A column in the currently used model.
    */
   void set_pixbuf_column(const TreeModelColumnBase& column);  
@@ -258,7 +206,7 @@ public:
   /** Returns the column with pixbufs for @a icon_view .
    * @return The pixbuf column, or -1 if it's unset.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_pixbuf_column() const;
 
@@ -266,7 +214,7 @@ public:
   /** Sets the ::orientation property which determines whether the labels 
    * are drawn beside the icons instead of below.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param orientation The relative position of texts and icons.
    */
   void set_orientation(Orientation orientation);
@@ -275,162 +223,47 @@ public:
    * whether the labels are drawn beside the icons instead of below.
    * @return The relative position of texts and icons 
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Orientation get_orientation() const;
 
   
-  /** Sets the ::columns property which determines in how
-   * many columns the icons are arranged. If @a columns  is
-   * -1, the number of columns will be chosen automatically 
-   * to fill the available area. 
-   * 
-   * @newin2p6
-   * @param columns The number of columns.
-   */
   void set_columns(int columns);
   
-  /** Returns the value of the ::columns property.
-   * @return The number of columns, or -1
-   * 
-   * @newin2p6.
-   */
   int get_columns() const;
   
-  /** Sets the ::item-width property which specifies the width 
-   * to use for each item. If it is set to -1, the icon view will 
-   * automatically determine a suitable item size.
-   * 
-   * @newin2p6
-   * @param item_width The width for each item.
-   */
   void set_item_width(int item_width);
   
-  /** Returns the value of the ::item-width property.
-   * @return The width of a single item, or -1
-   * 
-   * @newin2p6.
-   */
   int get_icon_width() const;
   
-  /** Sets the ::spacing property which specifies the space 
-   * which is inserted between the cells (i.e.\ the icon and 
-   * the text) of an item.
-   * 
-   * @newin2p6
-   * @param spacing The spacing.
-   */
   void set_spacing(int spacing);
   
-  /** Returns the value of the ::spacing property.
-   * @return The space between cells 
-   * 
-   * @newin2p6.
-   */
   int get_spacing() const;
   
-  /** Sets the ::row-spacing property which specifies the space 
-   * which is inserted between the rows of the icon view.
-   * 
-   * @newin2p6
-   * @param row_spacing The row spacing.
-   */
   void set_row_spacing(int row_spacing);
   
-  /** Returns the value of the ::row-spacing property.
-   * @return The space between rows
-   * 
-   * @newin2p6.
-   */
   gint get_row_spacing() const;
   
-  /** Sets the ::column-spacing property which specifies the space 
-   * which is inserted between the columns of the icon view.
-   * 
-   * @newin2p6
-   * @param column_spacing The column spacing.
-   */
   void set_column_spacing(int column_spacing);
   
-  /** Returns the value of the ::column-spacing property.
-   * @return The space between columns
-   * 
-   * @newin2p6.
-   */
   int get_column_spacing() const;
 
   
-  /** Sets the ::margin property which specifies the space 
-   * which is inserted at the top, bottom, left and right 
-   * of the icon view.
-   * 
-   * @newin2p6
-   * @param margin The margin.
-   */
   void set_margin(int margin);
   
-  /** Returns the value of the ::margin property.
-   * @return The space at the borders 
-   * 
-   * @newin2p6.
-   */
   int get_margin() const;
 
   
   /** Finds the path at the point ( @a x , @a y ), relative to widget coordinates.
-   * See get_item_at_pos(), if you are also interested in
-   * the cell at the specified position.
    * @param x The x position to be identified.
    * @param y The y position to be identified.
    * @return The Gtk::TreePath corresponding to the icon or <tt>0</tt>
    * if no icon exists at that position.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   TreeModel::Path get_path_at_pos(int x, int y) const;
 
-
-  /** Finds the path at the point (@a x, @a y), relative to widget coordinates.
-   *
-   * @param x The x position to be identified.
-   * @param y The y position to be identified.
-   * @param path The path.
-   * @param cell The renderer responsible for the cell at (@a x, @a y).
-   * 
-   * @result true if an item exists at the specified position.
-   *
-   * @newin2p6
-   */
-  bool get_item_at_pos(int x, int y, TreeModel::Path& path, CellRenderer*& cell) const;
-
-  /** Finds the path at the point (@a x, @a y), relative to widget coordinates.
-   *
-   * @param x The x position to be identified.
-   * @param y The y position to be identified.
-   * @param path The path.
-   * 
-   * @result true if an item exists at the specified position.
-   *
-   * @newin2p6
-   */
-  bool get_item_at_pos(int x, int y, TreeModel::Path& path) const;
-
-  /** Finds the path at the point (@a x, @a y), relative to widget coordinates.
-   *
-   * @param x The x position to be identified.
-   * @param y The y position to be identified.
-   * @param path The path.
-   * 
-   * @result true if an item exists at the specified position.
-   *
-   * @newin2p6
-   */
-  bool get_item_at_pos(int x, int y, CellRenderer*& cell) const;
-  
-
-  bool get_visible_range(TreeModel::Path& start_path, TreeModel::Path& end_path) const;
-  
-
   /** For instance, 
    * void on_foreach(const Gtk::TreeModel::Path& path);
    */
@@ -448,7 +281,7 @@ public:
   
   /** Sets the selection mode of the @a icon_view .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param mode The selection mode.
    */
   void set_selection_mode(SelectionMode mode);
@@ -456,20 +289,20 @@ public:
   /** Gets the selection mode of the @a icon_view .
    * @return The current selection mode
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   SelectionMode get_selection_mode() const;
   
   /** Selects the row at @a path .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param path The Gtk::TreePath to be selected.
    */
   void select_path(const TreeModel::Path& path);
   
   /** Unselects the row at @a path .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param path The Gtk::TreePath to be unselected.
    */
   void unselect_path(const TreeModel::Path& path);
@@ -479,11 +312,11 @@ public:
    * @param path A Gtk::TreePath to check selection on.
    * @return <tt>true</tt> if @a path  is selected.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool path_is_selected(const TreeModel::Path& path) const;
-
-
+  
+  
   #ifndef DOXYGEN_SHOULD_SKIP_THIS
   //TODO: I'm not sure about these to_*() functions. murrayc.
   struct TreePathTraits
@@ -514,270 +347,52 @@ public:
    * @endcode
    * @return A G::List containing a Gtk::TreePath for each selected row.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   ArrayHandle_TreePaths get_selected_items() const;
-
+  
   
   /** Selects all the icons. @a icon_view  must has its selection mode set
    * to Gtk::SELECTION_MULTIPLE.
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void select_all();
   
   /** Unselects all the icons.
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void unselect_all();
   
   /** Activates the item determined by @a path .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param path The Gtk::TreePath to be activated.
    */
   void item_activated(const TreeModel::Path& path);
 
-  void set_cursor(const TreeModel::Path& path, CellRenderer& cell, bool start_editing);
   
-
-  /** Fills in @a path and @a cell with the current cursor path and cell. 
-   * If the cursor isn't currently set, then @a path will be empty.
-   * If no cell currently has focus, then @a cell will be NULL.
-   *
-   * @param path The current cursor path.
-   * @param cell The current focus cell.
-   * @result true if the cursor is set.
-   *
-   * @newin2p8
-   */
-  bool get_cursor(TreeModel::Path& path, CellRenderer*& cell) const;
-
-  /** Fills in @a path and @a cell with the current cursor path and cell. 
-   * If the cursor isn't currently set, then @a path will be empty.
-   * If no cell currently has focus, then @a cell will be NULL.
-   *
-   * @param path The current cursor path.
-   * @result true if the cursor is set.
-   *
-   * @newin2p8
-   */
-  bool get_cursor(TreeModel::Path& path) const;
-
-  /** Fills in @a path and @a cell with the current cursor path and cell. 
-   * If the cursor isn't currently set, then @a path will be empty.
-   * If no cell currently has focus, then @a cell will be NULL.
-   *
-   * @param cell The current focus cell.
-   * @result true if the cursor is set.
-   *
-   * @newin2p8
-   */
-  bool get_cursor(CellRenderer*& cell) const;
-  
-
-  /** Moves the alignments of @a icon_view  to the position specified by @a path .  
-   *  @a row_align  determines where the row is placed, and @a col_align  determines where 
-   *  @a column  is placed.  Both are expected to be between 0.0 and 1.0. 
-   * 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means center.
-   * 
-   * If @a use_align  is <tt>false</tt>, then the alignment arguments are ignored, and the
-   * tree does the minimum amount of work to scroll the item onto the screen.
-   * This means that the item will be scrolled to the edge closest to its current
-   * position.  If the item is currently visible on the screen, nothing is done.
-   * 
-   * This function only works if the model is set, and @a path  is a valid row on the
-   * model.  If the model changes before the @a icon_view  is realized, the centered
-   * path will be modified to reflect this change.
-   * 
-   * @newin2p8
-   * @param path The path of the item to move to.
-   * @param use_align Whether to use alignment arguments, or <tt>false</tt>.
-   * @param row_align The vertical alignment of the item specified by @a path .
-   * @param col_align The horizontal alignment of the item specified by @a path .
-   */
-  void scroll_to_path(const TreeModel::Path& path, bool use_align, gfloat row_align, gfloat col_align);
-
-/* Drag-and-Drop support */
-  /**
-   * Turns the IconView into a drag source for automatic DND.
-   *
-   * @param targets Standard container of targets that the drag will support.
-   * @param start_button_mask Mask of allowed buttons to start drag.
-   * @param actions The bitmask of possible actions for a drag from this widget.
-   */
-  void enable_model_drag_source(const ArrayHandle_TargetEntry& targets,
-                                Gdk::ModifierType start_button_mask = Gdk::MODIFIER_MASK,
-                                Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
-  
-
-  /** Turns the IconView into a drop destination for automatic DND.
-   *
-   * @param targets The table of targets that the drag will support.
-   * @param actions The bitmask of possible actions for a drag from this widget.
-   */
-  void enable_model_drag_dest(const ArrayHandle_TargetEntry& targets, Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
-  
-
-  /** Undoes the effect of enable_model_drag_source().
-   * 
-   * @newin2p8
-   */
-  void unset_model_drag_source();
-  
-  /** Undoes the effect of enable_model_drag_dest().
-   * 
-   * @newin2p8
-   */
-  void unset_model_drag_dest();
-
-  
-  /** This function is a convenience function to allow you to reorder models that
-   * support the Gtk::TreeDragSourceIface and the Gtk::TreeDragDestIface.  Both
-   * Gtk::TreeStore and Gtk::ListStore support these.  If @a reorderable  is <tt>true</tt>, then
-   * the user can reorder the model by dragging and dropping rows.  The
-   * developer can listen to these changes by connecting to the model's
-   * row_inserted and row_deleted signals.
-   * 
-   * This function does not give you any degree of control over the order -- any
-   * reordering is allowed.  If more control is needed, you should probably
-   * handle drag and drop manually.
-   * 
-   * @newin2p8
-   * @param reorderable <tt>true</tt>, if the list of items can be reordered.
-   */
-  void set_reorderable(bool reorderable = true);
-  
-  /** Retrieves whether the user can reorder the list via drag-and-drop. 
-   * See set_reorderable().
-   * @return <tt>true</tt> if the list can be reordered.
-   * 
-   * @newin2p8.
-   */
-  bool get_reorderable() const;
-
-
-/* These are useful to implement your own custom stuff. */
-  //TODO: Discover what arguments are output arguments:
-  
-  /** Sets the item that is highlighted for feedback.
-   * 
-   * @newin2p8
-   * @param path The path of the item to highlight, or <tt>0</tt>.
-   * @param pos Specifies where to drop, relative to the item.
-   */
-  void set_drag_dest_item(const TreeModel::Path& path, IconViewDropPosition pos);
-
-  /** Gets information about the item that is highlighted for feedback.
-   *
-   * @param path The highlighted item.
-   * @pos The drop position.
-   *
-   * @newin2p10
-   */
-  void get_drag_dest_item(TreeModel::Path& path, IconViewDropPosition& pos) const;
-
-  /** Gets information about the item that is highlighted for feedback.
-   *
-   * @param path The highlighted item.
-   *
-   * @newin2p10
-   */
-  void get_drag_dest_item(TreeModel::Path& path) const;
-
-  /** Gets information about the item that is highlighted for feedback.
-   *
-   * @pos The drop position.
-   *
-   * @newin2p10
-   */
-  void get_drag_dest_item(IconViewDropPosition& pos) const;
-  
-
-  /** Determines the destination item for a given position.
-   *
-   * @param drag_x The position to determine the destination item for.
-   * @param drag_y the position to determine the destination item for.
-   * @param path The path of the item.
-   * @param pos: The drop position.
-   * @result whether there is an item at the given position.
-   *
-   * @newin2p10
-   */
-  bool get_dest_item_at_pos(int drag_x, int drag_y, TreeModel::Path& path, IconViewDropPosition& pos) const;
-
-  /** Determines the destination item for a given position.
-   *
-   * @param drag_x The position to determine the destination item for.
-   * @param drag_y the position to determine the destination item for.
-   * @param path The path of the item.
-   * @result whether there is an item at the given position.
-   *
-   * @newin2p10
-   */
-  bool get_dest_item_at_pos(int drag_x, int drag_y, TreeModel::Path& path) const;
-
-  /** Determines the destination item for a given position.
-   * 
-   * @param drag_x The position to determine the destination item for.
-   * @param drag_y the position to determine the destination item for.
-   * @param pos: The drop position.
-   * @result whether there is an item at the given position.
-   *
-   * @newin2p10
-   */
-  bool get_dest_item_at_pos(int drag_x, int drag_y, IconViewDropPosition& pos) const;
-  
-
-  /** Creates a Gdk::Pixmap representation of the item at @a path .  
-   * This image is used for a drag icon.
-   * @param path A Gtk::TreePath in @a icon_view .
-   * @return A newly-allocated pixmap of the drag icon.
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<Gdk::Pixmap> create_drag_icon( const TreeModel::Path& path);
-
-
-/**
-   * @par Prototype:
-   * <tt>void %set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)</tt>
-   */
-
   Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
  
   
-/**
-   * @par Prototype:
-   * <tt>void %item_activated(const TreeModel::Path& path)</tt>
-   */
-
   Glib::SignalProxy1< void,const TreeModel::Path& > signal_item_activated();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %selection_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_selection_changed();
 
 
   /* Key binding signals */
   
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Model column used to retrieve the icon pixbuf from.
+  /** Model column used to retrieve the icon pixbuf from.
    *
    * 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_pixbuf_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Model column used to retrieve the icon pixbuf from.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -785,19 +400,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_pixbuf_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Model column used to retrieve the text from.
+  /** Model column used to retrieve the text from.
    *
    * 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_text_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Model column used to retrieve the text from.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -805,19 +416,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_text_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Model column used to retrieve the text if using Pango markup.
+  /** Model column used to retrieve the text if using Pango 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<int> property_markup_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Model column used to retrieve the text if using Pango markup.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -825,19 +432,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_markup_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The selection mode.
+  /** The selection 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<SelectionMode> property_selection_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The selection mode.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -845,19 +448,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<SelectionMode> property_selection_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** How the text and icon of each item are positioned relative to each other.
+  /** How the text and icon of each item are positioned relative to each other.
    *
    * 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<Orientation> property_orientation() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** How the text and icon of each item are positioned relative to each other.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -865,19 +464,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Orientation> property_orientation() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The model for the icon view.
+  /** The model for the icon view.
    *
    * 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<TreeModel> > property_model() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The model for the icon view.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -885,19 +480,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > property_model() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of columns to display.
+  /** Number of columns to display.
    *
    * 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_columns() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Number of columns to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -905,19 +496,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_columns() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The width used for each item.
+  /** The width used for each item.
    *
    * 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_item_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The width used for each item.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -925,19 +512,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_item_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Space which is inserted between cells of an item.
+  /** Space which is inserted between cells of an item.
    *
    * 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_spacing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Space which is inserted between cells of an item.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -945,19 +528,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_spacing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Space which is inserted between grid rows.
+  /** Space which is inserted between grid rows.
    *
    * 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_row_spacing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Space which is inserted between grid rows.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -965,39 +544,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_row_spacing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Space which is inserted between grid columns.
+  /** Space which is inserted between grid column.
    *
    * 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_column_spacing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Space which is inserted between grid columns.
+/** Space which is inserted between grid column.
    *
    * 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_column_spacing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Space which is inserted at the edges of the icon view.
+  /** Space which is inserted at the edges of the icon view.
    *
    * 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_margin() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Space which is inserted at the edges of the icon view.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1005,7 +576,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_margin() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -1021,8 +591,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::IconView* wrap(GtkIconView* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ICONVIEW_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/image.cc b/libs/gtkmm2/gtk/gtkmm/image.cc
index 7a0a31b9e9..8152af1f7e 100644
--- a/libs/gtkmm2/gtk/gtkmm/image.cc
+++ b/libs/gtkmm2/gtk/gtkmm/image.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/image.h>
 #include <gtkmm/private/image_p.h>
 
@@ -97,6 +96,11 @@ void Image::get_icon_set(IconSet& icon_set, IconSize& size) const
   icon_set = Glib::wrap(pIconSet, true); //true = take_copy.
 }
 
+void Image::clear()
+{
+  gtk_image_set_from_pixbuf(gobj(), 0);
+}
+
 Glib::ustring Image::get_icon_name() const
 {
   const gchar* pchIconName = 0;
@@ -168,19 +172,8 @@ void Image_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Image_Class::wrap_new(GObject* o)
 {
@@ -258,47 +251,42 @@ Image::Image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
 
 void Image::set(const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask)
 {
-gtk_image_set_from_pixmap(gobj(), Glib::unwrap(pixmap), Glib::unwrap(mask)); 
+  gtk_image_set_from_pixmap(gobj(), Glib::unwrap(pixmap), Glib::unwrap(mask));
 }
 
 void Image::set(const Glib::RefPtr<Gdk::Image>& gdk_image, const Glib::RefPtr<Gdk::Bitmap>& mask)
 {
-gtk_image_set_from_image(gobj(), Glib::unwrap(gdk_image), Glib::unwrap(mask)); 
+  gtk_image_set_from_image(gobj(), Glib::unwrap(gdk_image), Glib::unwrap(mask));
 }
 
 void Image::set(const std::string& filename)
 {
-gtk_image_set_from_file(gobj(), filename.c_str()); 
+  gtk_image_set_from_file(gobj(), filename.c_str());
 }
 
 void Image::set(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
 {
-gtk_image_set_from_pixbuf(gobj(), Glib::unwrap(pixbuf)); 
+  gtk_image_set_from_pixbuf(gobj(), Glib::unwrap(pixbuf));
 }
 
 void Image::set(const Gtk::StockID& stock_id, IconSize size)
 {
-gtk_image_set_from_stock(gobj(), (stock_id).get_c_str(), static_cast<GtkIconSize>(int(size))); 
+  gtk_image_set_from_stock(gobj(), (stock_id).get_c_str(), static_cast<GtkIconSize>(int(size)));
 }
 
 void Image::set(IconSet& icon_set, IconSize size)
 {
-gtk_image_set_from_icon_set(gobj(), (icon_set).gobj(), static_cast<GtkIconSize>(int(size))); 
+  gtk_image_set_from_icon_set(gobj(), (icon_set).gobj(), static_cast<GtkIconSize>(int(size)));
 }
 
 void Image::set(const Glib::RefPtr<Gdk::PixbufAnimation>& animation)
 {
-gtk_image_set_from_animation(gobj(), Glib::unwrap(animation)); 
+  gtk_image_set_from_animation(gobj(), Glib::unwrap(animation));
 }
 
 void Image::set_from_icon_name(const Glib::ustring& icon_name, IconSize size)
 {
-gtk_image_set_from_icon_name(gobj(), icon_name.c_str(), static_cast<GtkIconSize>(int(size))); 
-}
-
-void Image::clear()
-{
-gtk_image_clear(gobj()); 
+  gtk_image_set_from_icon_name(gobj(), icon_name.c_str(), static_cast<GtkIconSize>(int(size)));
 }
 
 ImageType Image::get_storage_type() const
@@ -310,30 +298,40 @@ Glib::RefPtr<Gdk::Pixbuf> Image::get_pixbuf()
 {
 
   Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_image_get_pixbuf(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Pixbuf> Image::get_pixbuf() const
 {
-  return const_cast<Image*>(this)->get_pixbuf();
+
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_image_get_pixbuf(const_cast<GtkImage*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Gdk::PixbufAnimation> Image::get_animation()
 {
 
   Glib::RefPtr<Gdk::PixbufAnimation> retvalue = Glib::wrap(gtk_image_get_animation(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::PixbufAnimation> Image::get_animation() const
 {
-  return const_cast<Image*>(this)->get_animation();
+
+  Glib::RefPtr<const Gdk::PixbufAnimation> retvalue = Glib::wrap(gtk_image_get_animation(const_cast<GtkImage*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 int Image::get_pixel_size() const
@@ -343,149 +341,104 @@ int Image::get_pixel_size() const
 
 void Image::set_pixel_size(int pixel_size)
 {
-gtk_image_set_pixel_size(gobj(), pixel_size); 
+  gtk_image_set_pixel_size(gobj(), pixel_size);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > Image::property_pixbuf() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > Image::property_pixbuf() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> > Image::property_pixmap() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> >(this, "pixmap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > Image::property_pixmap() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> >(this, "pixmap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Image> > Image::property_image() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Image> >(this, "image");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Image> > Image::property_image() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Image> >(this, "image");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> > Image::property_mask() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixmap> >(this, "mask");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > Image::property_mask() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> >(this, "mask");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> Image::property_file() 
+Glib::PropertyProxy_WriteOnly<Glib::ustring> Image::property_file() 
 {
-  return Glib::PropertyProxy<Glib::ustring>(this, "file");
+  return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "file");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Image::property_file() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "file");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Image::property_stock() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "stock");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Image::property_stock() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::IconSet> Image::property_icon_set() 
 {
   return Glib::PropertyProxy<Gtk::IconSet>(this, "icon-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::IconSet> Image::property_icon_set() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::IconSet>(this, "icon-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Image::property_icon_size() 
 {
   return Glib::PropertyProxy<int>(this, "icon-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Image::property_icon_size() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "icon-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::PixbufAnimation> > Image::property_pixbuf_animation() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::PixbufAnimation> >(this, "pixbuf-animation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::PixbufAnimation> > Image::property_pixbuf_animation() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::PixbufAnimation> >(this, "pixbuf-animation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ImageType> Image::property_storage_type() const
 {
   return Glib::PropertyProxy_ReadOnly<ImageType>(this, "storage-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/image.h b/libs/gtkmm2/gtk/gtkmm/image.h
index 799be0c4d3..13775a2c92 100644
--- a/libs/gtkmm2/gtk/gtkmm/image.h
+++ b/libs/gtkmm2/gtk/gtkmm/image.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_IMAGE_H
 #define _GTKMM_IMAGE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -143,17 +142,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -166,20 +159,11 @@ public:
   explicit Image(const Glib::RefPtr<Gdk::Image>& image, const Glib::RefPtr<Gdk::Bitmap>& mask);
   explicit Image(const std::string& file);
   explicit Image(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
-
-  /** Creates am Image displaying a stock icon.
-   * Sample stock icon identifiers are Gtk::Stock::OPEN, Gtk::Stock::EXIT. Sample stock sizes are Gtk::ICON_SIZE_MENU, Gtk::ICON_SIZE_SMALL_TOOLBAR.
-   * If the stock icon name isn't known, a "broken image" icon will be displayed instead.
-   * You can register your own stock icon names - see Gtk::IconFactory::add().
-   * @param stock_id A stock icon.
-   * @param size A stock icon size.
-   */
   Image(const Gtk::StockID& stock_id, IconSize size);
-
   Image(IconSet& icon_set, IconSize size);
   Image(const Glib::RefPtr<Gdk::PixbufAnimation>& animation);
-
   
+
   /** See new_from_pixmap() for details.
    * @param pixmap A Gdk::Pixmap or <tt>0</tt>.
    * @param mask A Gdk::Bitmap or <tt>0</tt>.
@@ -202,7 +186,7 @@ public:
    */
   void set(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
   
-  /** See the Image::Image(const Gtk::StockID& stock_id, IconSize size) constructor for details.
+  /** See new_from_stock() for details.
    * @param stock_id A stock icon name.
    * @param size A stock icon size.
    */
@@ -222,17 +206,12 @@ public:
   
   /** See new_from_icon_name() for details.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param icon_name An icon name.
    * @param size An icon size.
    */
   void set_from_icon_name(const Glib::ustring& icon_name, IconSize size);
 
-  
-  /** Resets the image to be empty.
-   * 
-   * @newin2p8
-   */
   void clear();
 
   
@@ -283,7 +262,7 @@ public:
    * @return The displayed animation, or <tt>0</tt> if the image is empty.
    */
   Glib::RefPtr<const Gdk::PixbufAnimation> get_animation() const;
-
+  
   Glib::ustring get_icon_name() const;
   Glib::ustring get_icon_name(IconSize& size);
   
@@ -291,7 +270,7 @@ public:
   /** Gets the pixel size used for named icons.
    * @return The pixel size used for named icons.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_pixel_size() const;
  
@@ -299,22 +278,19 @@ public:
    * to a value != -1, it is used instead of the icon size set by
    * set_from_icon_name().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param pixel_size The new pixel size.
    */
   void set_pixel_size(int pixel_size);
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A GdkPixbuf to display.
+ 
+  /** A GdkPixbuf to display.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A GdkPixbuf to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -322,19 +298,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A GdkPixmap to display.
+  /** A GdkPixmap to display.
    *
    * 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::Pixmap> > property_pixmap() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A GdkPixmap to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -342,19 +314,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > property_pixmap() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A GdkImage to display.
+  /** A GdkImage to display.
    *
    * 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::Image> > property_image() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A GdkImage to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -362,19 +330,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Image> > property_image() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Mask bitmap to use with GdkImage or GdkPixmap.
+  /** Mask bitmap to use with GdkImage or GdkPixmap.
    *
    * 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::Pixmap> > property_mask() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Mask bitmap to use with GdkImage or GdkPixmap.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -382,19 +346,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixmap> > property_mask() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Filename to load and display.
+  /** Filename to load and display.
    *
    * 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_file() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy_WriteOnly<Glib::ustring> property_file() ;
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Filename to load and display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -402,19 +362,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_file() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Stock ID for a stock image to display.
+  /** Stock ID for a stock image to display.
    *
    * 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_stock() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Stock ID for a stock image to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -422,19 +378,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Icon set to display.
+  /** Icon set to display.
    *
    * 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::IconSet> property_icon_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Icon set to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -442,19 +394,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::IconSet> property_icon_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Symbolic size to use for stock icon
+  /** Symbolic size to use for stock icon
    *
    * 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_icon_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Symbolic size to use for stock icon
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -462,19 +410,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_icon_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** GdkPixbufAnimation to display.
+  /** GdkPixbufAnimation to display.
    *
    * 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::PixbufAnimation> > property_pixbuf_animation() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** GdkPixbufAnimation to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -482,17 +426,14 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::PixbufAnimation> > property_pixbuf_animation() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The representation being used for image data.
+  /** The representation being used for image data.
    *
    * 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<ImageType> property_storage_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -508,8 +449,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Image* wrap(GtkImage* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_IMAGE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/imagemenuitem.cc b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.cc
index 7543a2ddd1..61abd691cd 100644
--- a/libs/gtkmm2/gtk/gtkmm/imagemenuitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/imagemenuitem.h>
 #include <gtkmm/private/imagemenuitem_p.h>
 
@@ -123,19 +122,8 @@ void ImageMenuItem_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ImageMenuItem_Class::wrap_new(GObject* o)
 {
@@ -185,7 +173,7 @@ ImageMenuItem::ImageMenuItem()
 
 void ImageMenuItem::set_image(Widget& image)
 {
-gtk_image_menu_item_set_image(gobj(), (image).gobj()); 
+  gtk_image_menu_item_set_image(gobj(), (image).gobj());
 }
 
 Widget* ImageMenuItem::get_image()
@@ -195,17 +183,10 @@ Widget* ImageMenuItem::get_image()
 
 const Widget* ImageMenuItem::get_image() const
 {
-  return const_cast<ImageMenuItem*>(this)->get_image();
+  return Glib::wrap(gtk_image_menu_item_get_image(const_cast<GtkImageMenuItem*>(gobj())));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/imagemenuitem.h b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.h
index b5ba9d358a..f9f21f8002 100644
--- a/libs/gtkmm2/gtk/gtkmm/imagemenuitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/imagemenuitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_IMAGEMENUITEM_H
 #define _GTKMM_IMAGEMENUITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -94,17 +93,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -151,8 +144,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ImageMenuItem* wrap(GtkImageMenuItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_IMAGEMENUITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/inputdialog.cc b/libs/gtkmm2/gtk/gtkmm/inputdialog.cc
index 929a385f47..9ccbf28a10 100644
--- a/libs/gtkmm2/gtk/gtkmm/inputdialog.cc
+++ b/libs/gtkmm2/gtk/gtkmm/inputdialog.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/inputdialog.h>
 #include <gtkmm/private/inputdialog_p.h>
 
@@ -32,11 +31,11 @@
 #include <gtkmm/scrolledwindow.h>
 #include <gtkmm/table.h>
 
+
 namespace
 {
 
-
-static void InputDialog_signal_enable_device_callback(GtkInputDialog* self, GdkDevice* p0,void* data)
+void InputDialog_signal_enable_device_callback(GtkInputDialog* self, GdkDevice* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::Device>& > SlotType;
@@ -44,24 +43,20 @@ static void InputDialog_signal_enable_device_callback(GtkInputDialog* self, GdkD
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo InputDialog_signal_enable_device_info =
+const Glib::SignalProxyInfo InputDialog_signal_enable_device_info =
 {
   "enable_device",
   (GCallback) &InputDialog_signal_enable_device_callback,
@@ -69,7 +64,7 @@ static const Glib::SignalProxyInfo InputDialog_signal_enable_device_info =
 };
 
 
-static void InputDialog_signal_disable_device_callback(GtkInputDialog* self, GdkDevice* p0,void* data)
+void InputDialog_signal_disable_device_callback(GtkInputDialog* self, GdkDevice* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::Device>& > SlotType;
@@ -77,31 +72,26 @@ static void InputDialog_signal_disable_device_callback(GtkInputDialog* self, Gdk
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo InputDialog_signal_disable_device_info =
+const Glib::SignalProxyInfo InputDialog_signal_disable_device_info =
 {
   "disable_device",
   (GCallback) &InputDialog_signal_disable_device_callback,
   (GCallback) &InputDialog_signal_disable_device_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -146,19 +136,11 @@ void InputDialog_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->enable_device = &enable_device_callback;
   klass->disable_device = &disable_device_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void InputDialog_Class::enable_device_callback(GtkInputDialog* self, GdkDevice* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -171,20 +153,16 @@ void InputDialog_Class::enable_device_callback(GtkInputDialog* self, GdkDevice*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_enable_device(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -197,6 +175,7 @@ void InputDialog_Class::enable_device_callback(GtkInputDialog* self, GdkDevice*
       (*base->enable_device)(self, p0);
   }
 }
+
 void InputDialog_Class::disable_device_callback(GtkInputDialog* self, GdkDevice* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -209,20 +188,16 @@ void InputDialog_Class::disable_device_callback(GtkInputDialog* self, GdkDevice*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_disable_device(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -235,7 +210,6 @@ void InputDialog_Class::disable_device_callback(GtkInputDialog* self, GdkDevice*
       (*base->disable_device)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* InputDialog_Class::wrap_new(GObject* o)
@@ -284,7 +258,7 @@ InputDialog::InputDialog()
 {
   }
 
- Table* InputDialog::get_axis_list()
+Table* InputDialog::get_axis_list()
 {
   return Glib::wrap((GtkTable*)(gobj()->axis_list));
 }
@@ -293,8 +267,8 @@ const Table* InputDialog::get_axis_list() const
 {
   return Glib::wrap((GtkTable*)(gobj()->axis_list));
 }
- 
- ScrolledWindow* InputDialog::get_axis_box()
+
+ScrolledWindow* InputDialog::get_axis_box()
 {
   return Glib::wrap((GtkScrolledWindow*)(gobj()->axis_listbox));
 }
@@ -303,9 +277,8 @@ const ScrolledWindow* InputDialog::get_axis_box() const
 {
   return Glib::wrap((GtkScrolledWindow*)(gobj()->axis_listbox));
 }
- 
-#ifndef GTKMM_DISABLE_DEPRECATED
-   OptionMenu* InputDialog::get_mode_optionmenu()
+
+OptionMenu* InputDialog::get_mode_optionmenu()
 {
   return Glib::wrap((GtkOptionMenu*)(gobj()->mode_optionmenu));
 }
@@ -314,9 +287,8 @@ const OptionMenu* InputDialog::get_mode_optionmenu() const
 {
   return Glib::wrap((GtkOptionMenu*)(gobj()->mode_optionmenu));
 }
-#endif // GTKMM_DISABLE_DEPRECATED
-   
- Button* InputDialog::get_close_button()
+
+Button* InputDialog::get_close_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->close_button));
 }
@@ -325,8 +297,8 @@ const Button* InputDialog::get_close_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->close_button));
 }
- 
- Button* InputDialog::get_save_button()
+
+Button* InputDialog::get_save_button()
 {
   return Glib::wrap((GtkButton*)(gobj()->save_button));
 }
@@ -335,8 +307,8 @@ const Button* InputDialog::get_save_button() const
 {
   return Glib::wrap((GtkButton*)(gobj()->save_button));
 }
- 
- Glib::RefPtr<Gdk::Device> InputDialog::get_current_device()
+
+Glib::RefPtr<Gdk::Device> InputDialog::get_current_device()
 {
   Glib::RefPtr<Gdk::Device> ref_ptr(Glib::wrap(gobj()->current_device));
 
@@ -355,8 +327,8 @@ Glib::RefPtr<const Gdk::Device> InputDialog::get_current_device() const
 
   return ref_ptr;
 }
- 
- Table* InputDialog::get_keys_list()
+
+Table* InputDialog::get_keys_list()
 {
   return Glib::wrap((GtkTable*)(gobj()->keys_list));
 }
@@ -365,8 +337,8 @@ const Table* InputDialog::get_keys_list() const
 {
   return Glib::wrap((GtkTable*)(gobj()->keys_list));
 }
- 
- ScrolledWindow* InputDialog::get_keys_box()
+
+ScrolledWindow* InputDialog::get_keys_box()
 {
   return Glib::wrap((GtkScrolledWindow*)(gobj()->keys_listbox));
 }
@@ -375,21 +347,19 @@ const ScrolledWindow* InputDialog::get_keys_box() const
 {
   return Glib::wrap((GtkScrolledWindow*)(gobj()->keys_listbox));
 }
- 
+
 
 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > InputDialog::signal_enable_device()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& >(this, &InputDialog_signal_enable_device_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > InputDialog::signal_disable_device()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& >(this, &InputDialog_signal_disable_device_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::InputDialog::on_enable_device(const Glib::RefPtr<Gdk::Device>& device)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -399,6 +369,7 @@ void Gtk::InputDialog::on_enable_device(const Glib::RefPtr<Gdk::Device>& device)
   if(base && base->enable_device)
     (*base->enable_device)(gobj(),Glib::unwrap(device));
 }
+
 void Gtk::InputDialog::on_disable_device(const Glib::RefPtr<Gdk::Device>& device)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -408,10 +379,6 @@ void Gtk::InputDialog::on_disable_device(const Glib::RefPtr<Gdk::Device>& device
   if(base && base->disable_device)
     (*base->disable_device)(gobj(),Glib::unwrap(device));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/inputdialog.h b/libs/gtkmm2/gtk/gtkmm/inputdialog.h
index 45bf5d7eca..d5306cb778 100644
--- a/libs/gtkmm2/gtk/gtkmm/inputdialog.h
+++ b/libs/gtkmm2/gtk/gtkmm/inputdialog.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_INPUTDIALOG_H
 #define _GTKMM_INPUTDIALOG_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -43,13 +42,7 @@ namespace Gtk
 
 class Button;
 class Table;
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 class OptionMenu;
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
 class ScrolledWindow;
 
 // Don't list this in the documentation's Dialogs group because it isn't really useful
@@ -98,19 +91,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_enable_device(const Glib::RefPtr<Gdk::Device>& device);
   virtual void on_disable_device(const Glib::RefPtr<Gdk::Device>& device);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -121,44 +108,32 @@ public:
   InputDialog();
   
 
-   Table* get_axis_list();
+  Table* get_axis_list();
   const Table* get_axis_list() const;
-    ScrolledWindow* get_axis_box();
+  ScrolledWindow* get_axis_box();
   const ScrolledWindow* get_axis_box() const;
-   #ifndef GTKMM_DISABLE_DEPRECATED
-   OptionMenu* get_mode_optionmenu();
+  OptionMenu* get_mode_optionmenu();
   const OptionMenu* get_mode_optionmenu() const;
-#endif // GTKMM_DISABLE_DEPRECATED
-   
-   Button* get_close_button();
+
+  Button* get_close_button();
   const Button* get_close_button() const;
-    Button* get_save_button();
+  Button* get_save_button();
   const Button* get_save_button() const;
- 
+
   //GtkWidget *axis_items[GDK_AXIS_LAST];
 
-   Glib::RefPtr<Gdk::Device> get_current_device();
+  Glib::RefPtr<Gdk::Device> get_current_device();
   Glib::RefPtr<const Gdk::Device> get_current_device() const;
- 
-   Table* get_keys_list();
+
+  Table* get_keys_list();
   const Table* get_keys_list() const;
-    ScrolledWindow* get_keys_box();
+  ScrolledWindow* get_keys_box();
   const ScrolledWindow* get_keys_box() const;
- 
-  
-/**
-   * @par Prototype:
-   * <tt>void %enable_device(const Glib::RefPtr<Gdk::Device>& device)</tt>
-   */
 
+  
   Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > signal_enable_device();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %disable_device(const Glib::RefPtr<Gdk::Device>& device)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Device>& > signal_disable_device();
 
 
@@ -175,8 +150,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::InputDialog* wrap(GtkInputDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_INPUTDIALOG_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/invisible.cc b/libs/gtkmm2/gtk/gtkmm/invisible.cc
index b237050cbf..3c54f190da 100644
--- a/libs/gtkmm2/gtk/gtkmm/invisible.cc
+++ b/libs/gtkmm2/gtk/gtkmm/invisible.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/invisible.h>
 #include <gtkmm/private/invisible_p.h>
 
@@ -81,19 +80,8 @@ void Invisible_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Invisible_Class::wrap_new(GObject* o)
 {
@@ -152,30 +140,28 @@ Glib::RefPtr<Gdk::Screen> Invisible::get_screen()
 {
 
   Glib::RefPtr<Gdk::Screen> retvalue = Glib::wrap(gtk_invisible_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Screen> Invisible::get_screen() const
 {
-  return const_cast<Invisible*>(this)->get_screen();
+
+  Glib::RefPtr<const Gdk::Screen> retvalue = Glib::wrap(gtk_invisible_get_screen(const_cast<GtkInvisible*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Invisible::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
 {
-gtk_invisible_set_screen(gobj(), Glib::unwrap(screen)); 
+  gtk_invisible_set_screen(gobj(), Glib::unwrap(screen));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/invisible.h b/libs/gtkmm2/gtk/gtkmm/invisible.h
index 5c6112d21e..7e22cba573 100644
--- a/libs/gtkmm2/gtk/gtkmm/invisible.h
+++ b/libs/gtkmm2/gtk/gtkmm/invisible.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_INVISIBLE_H
 #define _GTKMM_INVISIBLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -89,17 +88,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -112,20 +105,20 @@ public:
   /** Returns the Gdk::Screen object associated with @a invisible 
    * @return The associated Gdk::Screen.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Gdk::Screen> get_screen();
   
   /** Returns the Gdk::Screen object associated with @a invisible 
    * @return The associated Gdk::Screen.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Gdk::Screen> get_screen() const;
   
   /** Sets the Gdk::Screen where the Gtk::Invisible object will be displayed.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param screen A Gdk::Screen.
    */
   void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
@@ -144,8 +137,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Invisible* wrap(GtkInvisible* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_INVISIBLE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/item.cc b/libs/gtkmm2/gtk/gtkmm/item.cc
index 0a8f2b122b..45e28f6fbc 100644
--- a/libs/gtkmm2/gtk/gtkmm/item.cc
+++ b/libs/gtkmm2/gtk/gtkmm/item.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/item.h>
 #include <gtkmm/private/item_p.h>
 
@@ -32,8 +31,7 @@
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Item_signal_select_info =
+const Glib::SignalProxyInfo Item_signal_select_info =
 {
   "select",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -41,7 +39,7 @@ static const Glib::SignalProxyInfo Item_signal_select_info =
 };
 
 
-static const Glib::SignalProxyInfo Item_signal_deselect_info =
+const Glib::SignalProxyInfo Item_signal_deselect_info =
 {
   "deselect",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -49,14 +47,13 @@ static const Glib::SignalProxyInfo Item_signal_deselect_info =
 };
 
 
-static const Glib::SignalProxyInfo Item_signal_toggle_info =
+const Glib::SignalProxyInfo Item_signal_toggle_info =
 {
   "toggle",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -101,20 +98,12 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->select = &select_callback;
   klass->deselect = &deselect_callback;
   klass->toggle = &toggle_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Item_Class::select_callback(GtkItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -127,19 +116,15 @@ void Item_Class::select_callback(GtkItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_select();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -152,6 +137,7 @@ void Item_Class::select_callback(GtkItem* self)
       (*base->select)(self);
   }
 }
+
 void Item_Class::deselect_callback(GtkItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -164,19 +150,15 @@ void Item_Class::deselect_callback(GtkItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_deselect();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -189,6 +171,7 @@ void Item_Class::deselect_callback(GtkItem* self)
       (*base->deselect)(self);
   }
 }
+
 void Item_Class::toggle_callback(GtkItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -201,19 +184,15 @@ void Item_Class::toggle_callback(GtkItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggle();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -226,7 +205,6 @@ void Item_Class::toggle_callback(GtkItem* self)
       (*base->toggle)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Item_Class::wrap_new(GObject* o)
@@ -270,17 +248,17 @@ GType Item::get_base_type()
 
 void Item::select()
 {
-gtk_item_select(gobj()); 
+  gtk_item_select(gobj());
 }
 
 void Item::deselect()
 {
-gtk_item_deselect(gobj()); 
+  gtk_item_deselect(gobj());
 }
 
 void Item::toggle()
 {
-gtk_item_toggle(gobj()); 
+  gtk_item_toggle(gobj());
 }
 
 Item::Item()
@@ -296,20 +274,17 @@ Glib::SignalProxy0< void > Item::signal_select()
   return Glib::SignalProxy0< void >(this, &Item_signal_select_info);
 }
 
-
 Glib::SignalProxy0< void > Item::signal_deselect()
 {
   return Glib::SignalProxy0< void >(this, &Item_signal_deselect_info);
 }
 
-
 Glib::SignalProxy0< void > Item::signal_toggle()
 {
   return Glib::SignalProxy0< void >(this, &Item_signal_toggle_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Item::on_select()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -319,6 +294,7 @@ void Gtk::Item::on_select()
   if(base && base->select)
     (*base->select)(gobj());
 }
+
 void Gtk::Item::on_deselect()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -328,6 +304,7 @@ void Gtk::Item::on_deselect()
   if(base && base->deselect)
     (*base->deselect)(gobj());
 }
+
 void Gtk::Item::on_toggle()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -337,10 +314,6 @@ void Gtk::Item::on_toggle()
   if(base && base->toggle)
     (*base->toggle)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/item.h b/libs/gtkmm2/gtk/gtkmm/item.h
index 73f33101d8..08405b5dd0 100644
--- a/libs/gtkmm2/gtk/gtkmm/item.h
+++ b/libs/gtkmm2/gtk/gtkmm/item.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_ITEM_H
 #define _GTKMM_ITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -91,20 +90,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_select();
   virtual void on_deselect();
   virtual void on_toggle();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -114,30 +107,18 @@ public:
   
   void select();
   
-/**
-   * @par Prototype:
-   * <tt>void %select()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_select();
 
 
   void deselect();
   
-/**
-   * @par Prototype:
-   * <tt>void %deselect()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_deselect();
 
 
   void toggle();
   
-/**
-   * @par Prototype:
-   * <tt>void %toggle()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_toggle();
 
@@ -159,8 +140,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Item* wrap(GtkItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_ITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/label.cc b/libs/gtkmm2/gtk/gtkmm/label.cc
index a594b621c4..0de70b9b64 100644
--- a/libs/gtkmm2/gtk/gtkmm/label.cc
+++ b/libs/gtkmm2/gtk/gtkmm/label.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/label.h>
 #include <gtkmm/private/label_p.h>
 
@@ -69,8 +68,7 @@ void Label::select_region(int start_offset)
 namespace
 {
 
-
-static void Label_signal_populate_popup_callback(GtkLabel* self, GtkMenu* p0,void* data)
+void Label_signal_populate_popup_callback(GtkLabel* self, GtkMenu* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Menu* > SlotType;
@@ -78,31 +76,26 @@ static void Label_signal_populate_popup_callback(GtkLabel* self, GtkMenu* p0,voi
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Label_signal_populate_popup_info =
+const Glib::SignalProxyInfo Label_signal_populate_popup_info =
 {
   "populate_popup",
   (GCallback) &Label_signal_populate_popup_callback,
   (GCallback) &Label_signal_populate_popup_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -147,18 +140,10 @@ void Label_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->populate_popup = &populate_popup_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Label_Class::populate_popup_callback(GtkLabel* self, GtkMenu* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -171,20 +156,16 @@ void Label_Class::populate_popup_callback(GtkLabel* self, GtkMenu* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_populate_popup(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -197,7 +178,6 @@ void Label_Class::populate_popup_callback(GtkLabel* self, GtkMenu* p0)
       (*base->populate_popup)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Label_Class::wrap_new(GObject* o)
@@ -241,7 +221,7 @@ GType Label::get_base_type()
 
 void Label::set_text(const Glib::ustring & str)
 {
-gtk_label_set_text(gobj(), str.c_str()); 
+  gtk_label_set_text(gobj(), str.c_str());
 }
 
 Glib::ustring Label::get_text() const
@@ -251,7 +231,7 @@ Glib::ustring Label::get_text() const
 
 void Label::set_attributes(Pango::AttrList& attrs)
 {
-gtk_label_set_attributes(gobj(), (attrs).gobj()); 
+  gtk_label_set_attributes(gobj(), (attrs).gobj());
 }
 
 Pango::AttrList Label::get_attributes() const
@@ -261,7 +241,7 @@ Pango::AttrList Label::get_attributes() const
 
 void Label::set_label(const Glib::ustring& str)
 {
-gtk_label_set_label(gobj(), str.c_str()); 
+  gtk_label_set_label(gobj(), str.c_str());
 }
 
 Glib::ustring Label::get_label() const
@@ -271,12 +251,12 @@ Glib::ustring Label::get_label() const
 
 void Label::set_markup(const Glib::ustring& str)
 {
-gtk_label_set_markup(gobj(), str.c_str()); 
+  gtk_label_set_markup(gobj(), str.c_str());
 }
 
 void Label::set_use_markup(bool setting)
 {
-gtk_label_set_use_markup(gobj(), static_cast<int>(setting)); 
+  gtk_label_set_use_markup(gobj(), static_cast<int>(setting));
 }
 
 bool Label::get_use_markup() const
@@ -286,7 +266,7 @@ bool Label::get_use_markup() const
 
 void Label::set_use_underline(bool setting)
 {
-gtk_label_set_use_underline(gobj(), static_cast<int>(setting)); 
+  gtk_label_set_use_underline(gobj(), static_cast<int>(setting));
 }
 
 bool Label::get_use_underline() const
@@ -296,7 +276,7 @@ bool Label::get_use_underline() const
 
 void Label::set_markup_with_mnemonic(const Glib::ustring& str)
 {
-gtk_label_set_markup_with_mnemonic(gobj(), str.c_str()); 
+  gtk_label_set_markup_with_mnemonic(gobj(), str.c_str());
 }
 
 guint Label::get_mnemonic_keyval() const
@@ -306,7 +286,7 @@ guint Label::get_mnemonic_keyval() const
 
 void Label::set_mnemonic_widget(Widget& widget)
 {
-gtk_label_set_mnemonic_widget(gobj(), (widget).gobj()); 
+  gtk_label_set_mnemonic_widget(gobj(), (widget).gobj());
 }
 
 Widget* Label::get_mnemonic_widget()
@@ -321,12 +301,12 @@ const Widget* Label::get_mnemonic_widget() const
 
 void Label::set_text_with_mnemonic(const Glib::ustring& str)
 {
-gtk_label_set_text_with_mnemonic(gobj(), str.c_str()); 
+  gtk_label_set_text_with_mnemonic(gobj(), str.c_str());
 }
 
 void Label::set_justify(Justification jtype)
 {
-gtk_label_set_justify(gobj(), ((GtkJustification)(jtype))); 
+  gtk_label_set_justify(gobj(), ((GtkJustification)(jtype)));
 }
 
 Justification Label::get_justify() const
@@ -336,7 +316,7 @@ Justification Label::get_justify() const
 
 void Label::set_ellipsize(Pango::EllipsizeMode mode)
 {
-gtk_label_set_ellipsize(gobj(), ((PangoEllipsizeMode)(mode))); 
+  gtk_label_set_ellipsize(gobj(), ((PangoEllipsizeMode)(mode)));
 }
 
 Pango::EllipsizeMode Label::get_ellipsize() const
@@ -346,7 +326,7 @@ Pango::EllipsizeMode Label::get_ellipsize() const
 
 void Label::set_width_chars(int n_chars)
 {
-gtk_label_set_width_chars(gobj(), n_chars); 
+  gtk_label_set_width_chars(gobj(), n_chars);
 }
 
 int Label::get_width_chars() const
@@ -356,7 +336,7 @@ int Label::get_width_chars() const
 
 void Label::set_max_width_chars(int n_chars)
 {
-gtk_label_set_max_width_chars(gobj(), n_chars); 
+  gtk_label_set_max_width_chars(gobj(), n_chars);
 }
 
 int Label::get_max_width_chars() const
@@ -366,12 +346,12 @@ int Label::get_max_width_chars() const
 
 void Label::set_pattern(const Glib::ustring& pattern)
 {
-gtk_label_set_pattern(gobj(), pattern.c_str()); 
+  gtk_label_set_pattern(gobj(), pattern.c_str());
 }
 
 void Label::set_line_wrap(bool wrap)
 {
-gtk_label_set_line_wrap(gobj(), static_cast<int>(wrap)); 
+  gtk_label_set_line_wrap(gobj(), static_cast<int>(wrap));
 }
 
 bool Label::get_line_wrap() const
@@ -379,19 +359,9 @@ bool Label::get_line_wrap() const
   return gtk_label_get_line_wrap(const_cast<GtkLabel*>(gobj()));
 }
 
-void Label::set_line_wrap_mode(Pango::WrapMode wrap_mode)
-{
-gtk_label_set_line_wrap_mode(gobj(), ((PangoWrapMode)(wrap_mode))); 
-}
-
-Pango::WrapMode Label::get_line_wrap_mode() const
-{
-  return ((Pango::WrapMode)(gtk_label_get_line_wrap_mode(const_cast<GtkLabel*>(gobj()))));
-}
-
 void Label::set_selectable(bool setting)
 {
-gtk_label_set_selectable(gobj(), static_cast<int>(setting)); 
+  gtk_label_set_selectable(gobj(), static_cast<int>(setting));
 }
 
 bool Label::get_selectable() const
@@ -401,7 +371,7 @@ bool Label::get_selectable() const
 
 void Label::set_angle(double angle)
 {
-gtk_label_set_angle(gobj(), angle); 
+  gtk_label_set_angle(gobj(), angle);
 }
 
 double Label::get_angle() const
@@ -411,7 +381,7 @@ double Label::get_angle() const
 
 void Label::select_region(int start_offset, int end_offset)
 {
-gtk_label_select_region(gobj(), start_offset, end_offset); 
+  gtk_label_select_region(gobj(), start_offset, end_offset);
 }
 
 bool Label::get_selection_bounds(int& start, int& end) const
@@ -423,25 +393,30 @@ Glib::RefPtr<Pango::Layout> Label::get_layout()
 {
 
   Glib::RefPtr<Pango::Layout> retvalue = Glib::wrap(gtk_label_get_layout(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Pango::Layout> Label::get_layout() const
 {
-  return const_cast<Label*>(this)->get_layout();
+
+  Glib::RefPtr<const Pango::Layout> retvalue = Glib::wrap(gtk_label_get_layout(const_cast<GtkLabel*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Label::get_layout_offsets(int& x, int& y) const
 {
-gtk_label_get_layout_offsets(const_cast<GtkLabel*>(gobj()), &x, &y); 
+  gtk_label_get_layout_offsets(const_cast<GtkLabel*>(gobj()), &x, &y);
 }
 
 void Label::set_single_line_mode(bool single_line_mode)
 {
-gtk_label_set_single_line_mode(gobj(), static_cast<int>(single_line_mode)); 
+  gtk_label_set_single_line_mode(gobj(), static_cast<int>(single_line_mode));
 }
 
 bool Label::get_single_line_mode() const
@@ -456,232 +431,162 @@ Glib::SignalProxy1< void,Menu* > Label::signal_populate_popup()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Label::property_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Label::property_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::AttrList> Label::property_attributes() 
 {
   return Glib::PropertyProxy<Pango::AttrList>(this, "attributes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::AttrList> Label::property_attributes() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::AttrList>(this, "attributes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Label::property_use_markup() 
 {
   return Glib::PropertyProxy<bool>(this, "use-markup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Label::property_use_markup() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-markup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Label::property_use_underline() 
 {
   return Glib::PropertyProxy<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Label::property_use_underline() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Justification> Label::property_justify() 
 {
   return Glib::PropertyProxy<Justification>(this, "justify");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Justification> Label::property_justify() const
 {
   return Glib::PropertyProxy_ReadOnly<Justification>(this, "justify");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> Label::property_pattern() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "pattern");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<Glib::ustring> Label::property_pattern() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "pattern");
+}
+
 Glib::PropertyProxy<bool> Label::property_wrap() 
 {
   return Glib::PropertyProxy<bool>(this, "wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Label::property_wrap() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Pango::WrapMode> Label::property_wrap_mode() 
-{
-  return Glib::PropertyProxy<Pango::WrapMode>(this, "wrap-mode");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Pango::WrapMode> Label::property_wrap_mode() const
-{
-  return Glib::PropertyProxy_ReadOnly<Pango::WrapMode>(this, "wrap-mode");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Label::property_selectable() 
 {
   return Glib::PropertyProxy<bool>(this, "selectable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Label::property_selectable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "selectable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Label::property_mnemonic_keyval() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "mnemonic-keyval");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Widget*> Label::property_mnemonic_widget() 
 {
   return Glib::PropertyProxy<Widget*>(this, "mnemonic-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Widget*> Label::property_mnemonic_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "mnemonic-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Label::property_cursor_position() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "cursor-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Label::property_selection_bound() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "selection-bound");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::EllipsizeMode> Label::property_ellipsize() 
 {
   return Glib::PropertyProxy<Pango::EllipsizeMode>(this, "ellipsize");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode> Label::property_ellipsize() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode>(this, "ellipsize");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Label::property_width_chars() 
 {
   return Glib::PropertyProxy<int>(this, "width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Label::property_width_chars() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Label::property_single_line_mode() 
 {
   return Glib::PropertyProxy<bool>(this, "single-line-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Label::property_single_line_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "single-line-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Label::property_angle() 
 {
   return Glib::PropertyProxy<double>(this, "angle");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Label::property_angle() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "angle");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Label::property_max_width_chars() 
 {
   return Glib::PropertyProxy<int>(this, "max-width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Label::property_max_width_chars() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "max-width-chars");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Label::on_populate_popup(Menu* menu)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -691,10 +596,6 @@ void Gtk::Label::on_populate_popup(Menu* menu)
   if(base && base->populate_popup)
     (*base->populate_popup)(gobj(),(GtkMenu*)Glib::unwrap(menu));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/label.h b/libs/gtkmm2/gtk/gtkmm/label.h
index 1536fe73c2..83d3b68bf0 100644
--- a/libs/gtkmm2/gtk/gtkmm/label.h
+++ b/libs/gtkmm2/gtk/gtkmm/label.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_LABEL_H
 #define _GTKMM_LABEL_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -92,18 +91,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_populate_popup(Menu* menu);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -200,7 +193,7 @@ public:
    * @code
    * char *markup;
    * &lt;!-- --&gt;
-   * markup = g_markup_printf_escaped ("&lt;span style=\"italic\"&gt;&percnt;s&lt;/span&gt;", str);
+   * markup = g_markup_printf_escaped ("&lt;span style=\"italic\"&gt;%s&lt;/span&gt;", str);
    * gtk_label_set_markup (GTK_LABEL (label), markup);
    * g_free (markup);
    * @endcode
@@ -313,7 +306,7 @@ public:
   /** Sets the mode used to ellipsize (add an ellipsis: "...") to the text if there
    * is not enough space to render the entire string.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param mode A Pango::EllipsizeMode.
    */
   void set_ellipsize(Pango::EllipsizeMode mode);
@@ -321,14 +314,14 @@ public:
   /** Returns the ellipsizing position of the label. See set_ellipsize().
    * @return Pango::EllipsizeMode
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Pango::EllipsizeMode get_ellipsize() const;
 
   
   /** Sets the desired width in characters of @a label  to @a n_chars .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param n_chars The new desired width, in characters.
    */
   void set_width_chars(int n_chars);
@@ -337,14 +330,14 @@ public:
    * set_width_chars().
    * @return The width of the label in characters.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_width_chars() const;
 
   
   /** Sets the desired maximum width in characters of @a label  to @a n_chars .
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param n_chars The new desired maximum width, in characters.
    */
   void set_max_width_chars(int n_chars);
@@ -353,7 +346,7 @@ public:
    * set_width_chars().
    * @return The maximum width of the label in characters.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   int get_max_width_chars() const;
 
@@ -372,10 +365,6 @@ public:
    */
   bool get_line_wrap() const;
   
-  void set_line_wrap_mode(Pango::WrapMode wrap_mode);
-  
-  Pango::WrapMode get_line_wrap_mode() const;
-  
   /** Selectable labels allow the user to select text from the label, for
    * copy-and-paste.
    * @param setting <tt>true</tt> to allow selecting text in the label.
@@ -392,7 +381,7 @@ public:
    * setting for the label is ignored if the label is selectable,
    * wrapped, or ellipsized.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param angle The angle that the baseline of the label makes with
    * the horizontal, in degrees, measured counterclockwise.
    */
@@ -402,7 +391,7 @@ public:
    * gtk_label_set_angle.
    * @return The angle of rotation for the label
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   double get_angle() const;
   
@@ -464,7 +453,7 @@ public:
   
   /** Sets whether the label is in single line mode.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param single_line_mode <tt>true</tt> if the label should be in single line mode.
    */
   void set_single_line_mode(bool single_line_mode = true);
@@ -472,33 +461,25 @@ public:
   /** Returns whether the label is in single line mode.
    * @return <tt>true</tt> when the label is in single line mode.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_single_line_mode() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %populate_popup(Menu* menu)</tt>
-   */
-
   Glib::SignalProxy1< void,Menu* > signal_populate_popup();
 
 
   //Keybinding signals:
   
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The text of the label.
+  /** The text of the label.
    *
    * 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_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The text of the label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -506,19 +487,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A list of style attributes to apply to the text of the label.
+  /** A list of style attributes to apply to the text of the label.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A list of style attributes to apply to the text of the label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -526,19 +503,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::AttrList> property_attributes() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The text of the label includes XML markup. See pango_parse_markup.
+  /** The text of the label includes XML markup. See pango_parse_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<bool> property_use_markup() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The text of the label includes XML markup. See pango_parse_markup.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -546,19 +519,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_markup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If set
+  /** If 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<bool> property_use_underline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -566,19 +535,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See GtkMisc::xalign for that.
+  /** The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See GtkMisc::xalign for that.
    *
    * 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<Justification> property_justify() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See GtkMisc::xalign for that.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -586,70 +551,47 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Justification> property_justify() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A string with _ characters in positions correspond to characters in the text to underline.
+  /** A string with _ characters in positions correspond to characters in the text to 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_WriteOnly<Glib::ustring> property_pattern() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If 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<bool> property_wrap() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** If set
+/** A string with _ characters in positions correspond to characters in the text to 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<bool> property_wrap() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy_ReadOnly<Glib::ustring> property_pattern() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If wrap is set
+  /** If 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<Pango::WrapMode> property_wrap_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy<bool> property_wrap() ;
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** If wrap is set
+/** If 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<Pango::WrapMode> property_wrap_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy_ReadOnly<bool> property_wrap() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the label text can be selected with the mouse.
+  /** Whether the label text can be selected with the mouse.
    *
    * 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_selectable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the label text can be selected with the mouse.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -657,30 +599,24 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_selectable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The mnemonic accelerator key for this label.
+  /** The mnemonic accelerator key for this label.
    *
    * 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_mnemonic_keyval() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The widget to be activated when the label's mnemonic key is pressed.
+  /** The widget to be activated when the label's mnemonic key is pressed.
    *
    * 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<Widget*> property_mnemonic_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The widget to be activated when the label's mnemonic key is pressed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -688,41 +624,33 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Widget*> property_mnemonic_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current position of the insertion cursor in chars.
+  /** The current position of the insertion cursor in chars.
    *
    * 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_cursor_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The position of the opposite end of the selection from the cursor in chars.
+  /** The position of the opposite end of the selection from the cursor in chars.
    *
    * 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_selection_bound() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The preferred place to ellipsize the string
+  /** The preferred place to ellipsize the string
    *
    * 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::EllipsizeMode> property_ellipsize() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The preferred place to ellipsize the string
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -730,19 +658,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::EllipsizeMode> property_ellipsize() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The desired width of the label
+  /** The desired width of the label
    *
    * 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_width_chars() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The desired width of the label
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -750,19 +674,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_width_chars() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
     
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the label is in single line mode.
+  /** Whether the label is in single line 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<bool> property_single_line_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the label is in single line mode.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -770,19 +690,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_single_line_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Angle at which the label is rotated.
+  /** Angle at which the label is rotated.
    *
    * 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_angle() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Angle at which the label is rotated.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -790,19 +706,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_angle() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The desired maximum width of the label
+  /** The desired maximum width of the label
    *
    * 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_max_width_chars() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The desired maximum width of the label
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -810,7 +722,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_max_width_chars() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -826,8 +737,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Label* wrap(GtkLabel* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_LABEL_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/layout.cc b/libs/gtkmm2/gtk/gtkmm/layout.cc
index ef96a49e85..366df0ea6f 100644
--- a/libs/gtkmm2/gtk/gtkmm/layout.cc
+++ b/libs/gtkmm2/gtk/gtkmm/layout.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/layout.h>
 #include <gtkmm/private/layout_p.h>
 
@@ -85,8 +84,7 @@ void Layout::set_vadjustment()
 namespace
 {
 
-
-static void Layout_signal_set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+void Layout_signal_set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
@@ -94,32 +92,27 @@ static void Layout_signal_set_scroll_adjustments_callback(GtkLayout* self, GtkAd
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Layout_signal_set_scroll_adjustments_info =
+const Glib::SignalProxyInfo Layout_signal_set_scroll_adjustments_info =
 {
   "set_scroll_adjustments",
   (GCallback) &Layout_signal_set_scroll_adjustments_callback,
   (GCallback) &Layout_signal_set_scroll_adjustments_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -164,18 +157,10 @@ void Layout_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Layout_Class::set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0, GtkAdjustment* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -188,21 +173,17 @@ void Layout_Class::set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustmen
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_scroll_adjustments(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -215,7 +196,6 @@ void Layout_Class::set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustmen
       (*base->set_scroll_adjustments)(self, p0, p1);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Layout_Class::wrap_new(GObject* o)
@@ -259,27 +239,27 @@ GType Layout::get_base_type()
 
 void Layout::put(Widget& child_widget, int x, int y)
 {
-gtk_layout_put(gobj(), (child_widget).gobj(), x, y); 
+  gtk_layout_put(gobj(), (child_widget).gobj(), x, y);
 }
 
 void Layout::move(Widget& child_widget, int x, int y)
 {
-gtk_layout_move(gobj(), (child_widget).gobj(), x, y); 
+  gtk_layout_move(gobj(), (child_widget).gobj(), x, y);
 }
 
 void Layout::set_size(guint width, guint height)
 {
-gtk_layout_set_size(gobj(), width, height); 
+  gtk_layout_set_size(gobj(), width, height);
 }
 
 void Layout::get_size(guint& width, guint& height) const
 {
-gtk_layout_get_size(const_cast<GtkLayout*>(gobj()), &(width), &(height)); 
+  gtk_layout_get_size(const_cast<GtkLayout*>(gobj()), &(width), &(height));
 }
 
 void Layout::set_hadjustment(Adjustment& adjustment)
 {
-gtk_layout_set_hadjustment(gobj(), (adjustment).gobj()); 
+  gtk_layout_set_hadjustment(gobj(), (adjustment).gobj());
 }
 
 Adjustment* Layout::get_hadjustment()
@@ -289,12 +269,12 @@ Adjustment* Layout::get_hadjustment()
 
 const Adjustment* Layout::get_hadjustment() const
 {
-  return const_cast<Layout*>(this)->get_hadjustment();
+  return Glib::wrap(gtk_layout_get_hadjustment(const_cast<GtkLayout*>(gobj())));
 }
 
 void Layout::set_vadjustment(Adjustment& adjustment)
 {
-gtk_layout_set_vadjustment(gobj(), (adjustment).gobj()); 
+  gtk_layout_set_vadjustment(gobj(), (adjustment).gobj());
 }
 
 Adjustment* Layout::get_vadjustment()
@@ -304,10 +284,10 @@ Adjustment* Layout::get_vadjustment()
 
 const Adjustment* Layout::get_vadjustment() const
 {
-  return const_cast<Layout*>(this)->get_vadjustment();
+  return Glib::wrap(gtk_layout_get_vadjustment(const_cast<GtkLayout*>(gobj())));
 }
 
- Glib::RefPtr<Gdk::Window> Layout::get_bin_window()
+Glib::RefPtr<Gdk::Window> Layout::get_bin_window()
 {
   Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->bin_window)));
 
@@ -326,7 +306,7 @@ Glib::RefPtr<const Gdk::Window> Layout::get_bin_window() const
 
   return ref_ptr;
 }
- 
+
 
 Glib::SignalProxy2< void,Adjustment*,Adjustment* > Layout::signal_set_scroll_adjustments()
 {
@@ -334,64 +314,47 @@ Glib::SignalProxy2< void,Adjustment*,Adjustment* > Layout::signal_set_scroll_adj
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Adjustment*> Layout::property_hadjustment() 
 {
   return Glib::PropertyProxy<Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Adjustment*> Layout::property_hadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Adjustment*> Layout::property_vadjustment() 
 {
   return Glib::PropertyProxy<Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Adjustment*> Layout::property_vadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Layout::property_width() 
 {
   return Glib::PropertyProxy<guint>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Layout::property_width() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Layout::property_height() 
 {
   return Glib::PropertyProxy<guint>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Layout::property_height() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Layout::on_set_scroll_adjustments(Adjustment* hadj, Adjustment* vadj)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -401,10 +364,6 @@ void Gtk::Layout::on_set_scroll_adjustments(Adjustment* hadj, Adjustment* vadj)
   if(base && base->set_scroll_adjustments)
     (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadj),(GtkAdjustment*)Glib::unwrap(vadj));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/layout.h b/libs/gtkmm2/gtk/gtkmm/layout.h
index 76dd9c2739..107cf725ff 100644
--- a/libs/gtkmm2/gtk/gtkmm/layout.h
+++ b/libs/gtkmm2/gtk/gtkmm/layout.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_LAYOUT_H
 #define _GTKMM_LAYOUT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -103,18 +102,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_set_scroll_adjustments(Adjustment* hadj, Adjustment* vadj);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -215,30 +208,23 @@ public:
    */
   const Adjustment* get_vadjustment() const;
 
-   Glib::RefPtr<Gdk::Window> get_bin_window();
+  Glib::RefPtr<Gdk::Window> get_bin_window();
   Glib::RefPtr<const Gdk::Window> get_bin_window() const;
- 
+
   // See Gtk::Widget::set_scroll_adjustments()
   
-/**
-   * @par Prototype:
-   * <tt>void %set_scroll_adjustments(Adjustment* hadj, Adjustment* vadj)</tt>
-   */
 
   Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkAdjustment for the horizontal position.
+  /** The GtkAdjustment for the horizontal position.
    *
    * 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<Adjustment*> property_hadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkAdjustment for the horizontal position.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -246,19 +232,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Adjustment*> property_hadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkAdjustment for the vertical position.
+  /** The GtkAdjustment for the vertical position.
    *
    * 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<Adjustment*> property_vadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkAdjustment for the vertical position.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -266,19 +248,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Adjustment*> property_vadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The width of the layout.
+  /** The width of the layout.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The width of the layout.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -286,19 +264,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The height of the layout.
+  /** The height of the layout.
    *
    * 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_height() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The height of the layout.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -306,7 +280,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -322,8 +295,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Layout* wrap(GtkLayout* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_LAYOUT_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/linkbutton.cc b/libs/gtkmm2/gtk/gtkmm/linkbutton.cc
deleted file mode 100644
index 6f24067e31..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/linkbutton.cc
+++ /dev/null
@@ -1,193 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/linkbutton.h>
-#include <gtkmm/private/linkbutton_p.h>
-
-// -*- c++ -*-
-/* $Id: linkbutton.ccg,v 1.1 2006/01/29 12:21:43 murrayc Exp $ */
-
-/*
- *
- * Copyright 2006 The gtkmm 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 <gtk/gtklinkbutton.h>
-
-namespace Gtk
-{
-
-
-} // namespace Gtk
-
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::LinkButton* wrap(GtkLinkButton* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::LinkButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& LinkButton_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_ = &LinkButton_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(gtk_link_button_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void LinkButton_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* LinkButton_Class::wrap_new(GObject* o)
-{
-  return manage(new LinkButton((GtkLinkButton*)(o)));
-
-}
-
-
-/* The implementation: */
-
-LinkButton::LinkButton(const Glib::ConstructParams& construct_params)
-:
-  Gtk::Button(construct_params)
-{
-  }
-
-LinkButton::LinkButton(GtkLinkButton* castitem)
-:
-  Gtk::Button((GtkButton*)(castitem))
-{
-  }
-
-LinkButton::~LinkButton()
-{
-  destroy_();
-}
-
-LinkButton::CppClassType LinkButton::linkbutton_class_; // initialize static member
-
-GType LinkButton::get_type()
-{
-  return linkbutton_class_.init().get_type();
-}
-
-GType LinkButton::get_base_type()
-{
-  return gtk_link_button_get_type();
-}
-
-
-LinkButton::LinkButton()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Button(Glib::ConstructParams(linkbutton_class_.init()))
-{
-  }
-
-LinkButton::LinkButton(const Glib::ustring& uri)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Button(Glib::ConstructParams(linkbutton_class_.init(), "uri", uri.c_str(), (char*) 0))
-{
-  }
-
-LinkButton::LinkButton(const Glib::ustring& uri, const Glib::ustring& label)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Button(Glib::ConstructParams(linkbutton_class_.init(), "uri", uri.c_str(), "label", label.c_str(), (char*) 0))
-{
-  }
-
-Glib::ustring LinkButton::get_uri() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_link_button_get_uri(const_cast<GtkLinkButton*>(gobj())));
-}
-
-void LinkButton::set_uri(const Glib::ustring& uri)
-{
-gtk_link_button_set_uri(gobj(), uri.c_str()); 
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> LinkButton::property_uri() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "uri");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> LinkButton::property_uri() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "uri");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/linkbutton.h b/libs/gtkmm2/gtk/gtkmm/linkbutton.h
deleted file mode 100644
index 093b60dfc1..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/linkbutton.h
+++ /dev/null
@@ -1,160 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_LINKBUTTON_H
-#define _GTKMM_LINKBUTTON_H
-
-
-#include <glibmm.h>
-
-/* $Id: linkbutton.hg,v 1.2 2006/03/22 16:53:22 murrayc Exp $ */
-
-/* linkbutton.h
- * 
- * Copyright (C) 2006 The gtkmm 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/button.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkLinkButton GtkLinkButton;
-typedef struct _GtkLinkButtonClass GtkLinkButtonClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class LinkButton_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** TODO
- *
- * @newin2p10
- * @ingroup Widgets
- */
-
-class LinkButton : public Button
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef LinkButton CppObjectType;
-  typedef LinkButton_Class CppClassType;
-  typedef GtkLinkButton BaseObjectType;
-  typedef GtkLinkButtonClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~LinkButton();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class LinkButton_Class;
-  static CppClassType linkbutton_class_;
-
-  // noncopyable
-  LinkButton(const LinkButton&);
-  LinkButton& operator=(const LinkButton&);
-
-protected:
-  explicit LinkButton(const Glib::ConstructParams& construct_params);
-  explicit LinkButton(GtkLinkButton* 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.
-  GtkLinkButton*       gobj()       { return reinterpret_cast<GtkLinkButton*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkLinkButton* gobj() const { return reinterpret_cast<GtkLinkButton*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-public:
-  LinkButton();
-  explicit LinkButton(const Glib::ustring& uri);
-  explicit LinkButton(const Glib::ustring& uri, const Glib::ustring& label);
-
-  
-  Glib::ustring get_uri() const;
-  
-  void set_uri(const Glib::ustring& uri);
-
-
-  //TODO: GtkLinkButtonUriFunc  gtk_link_button_set_uri_hook(GtkLinkButtonUriFunc func, gpointer data, GDestroyNotify destroy);
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The URI bound to this button.
-   *
-   * 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_uri() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The URI bound to this button.
-   *
-   * 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_uri() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-                                           
-
-};
-
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::LinkButton
-   * @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.
-   */
-  Gtk::LinkButton* wrap(GtkLinkButton* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_LINKBUTTON_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/liststore.cc b/libs/gtkmm2/gtk/gtkmm/liststore.cc
index e79dbd3a02..dadeb5f4f5 100644
--- a/libs/gtkmm2/gtk/gtkmm/liststore.cc
+++ b/libs/gtkmm2/gtk/gtkmm/liststore.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/liststore.h>
 #include <gtkmm/private/liststore_p.h>
 
@@ -189,19 +188,8 @@ void ListStore_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ListStore_Class::wrap_new(GObject* object)
 {
@@ -257,12 +245,12 @@ Glib::RefPtr<ListStore> ListStore::create(const TreeModelColumnRecord& columns)
 }
 void ListStore::iter_swap(const iterator& a, const iterator& b)
 {
-gtk_list_store_swap(gobj(), const_cast<GtkTreeIter*>((a).gobj()), const_cast<GtkTreeIter*>((b).gobj())); 
+  gtk_list_store_swap(gobj(), const_cast<GtkTreeIter*>((a).gobj()), const_cast<GtkTreeIter*>((b).gobj()));
 }
 
 void ListStore::clear()
 {
-gtk_list_store_clear(gobj()); 
+  gtk_list_store_clear(gobj());
 }
 
 bool ListStore::iter_is_valid(const iterator& iter) const
@@ -271,13 +259,6 @@ bool ListStore::iter_is_valid(const iterator& iter) const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/liststore.h b/libs/gtkmm2/gtk/gtkmm/liststore.h
index b0065ea51a..9d2fe355e2 100644
--- a/libs/gtkmm2/gtk/gtkmm/liststore.h
+++ b/libs/gtkmm2/gtk/gtkmm/liststore.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_LISTSTORE_H
 #define _GTKMM_LISTSTORE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -177,7 +176,7 @@ public:
   /** Swaps @a a  and @a b  in @a store . Note that this function only works with
    * unsorted stores.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param a A Gtk::TreeIter.
    * @param b Another Gtk::TreeIter.
    */
@@ -208,7 +207,7 @@ public:
    * @param iter A Gtk::TreeIter.
    * @return <tt>true</tt> if the iter is valid, <tt>false</tt> if the iter is invalid.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool iter_is_valid(const iterator& iter) const;
 
@@ -220,17 +219,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/listviewtext.cc b/libs/gtkmm2/gtk/gtkmm/listviewtext.cc
deleted file mode 100644
index eda235749e..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/listviewtext.cc
+++ /dev/null
@@ -1,183 +0,0 @@
-/* Copyright(C) 2006 The gtkmm 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/listviewtext.h>
-
-namespace Gtk
-{
-
-ListViewText::TextModelColumns::TextModelColumns(guint columns_count)
-: m_columns_count(columns_count)
-{
-  m_columns = new Gtk::TreeModelColumn<Glib::ustring>[m_columns_count];
-
-  if(m_columns)
-  {
-    for(guint i = 0; i < m_columns_count; ++i)
-    {
-      add(m_columns[i]);
-    }
-  }
-}
-
-ListViewText::TextModelColumns::~TextModelColumns()
-{
-  if(m_columns)
-    delete[] m_columns;
-}
-
-guint ListViewText::TextModelColumns::get_num_columns() const
-{
-  return m_columns_count;
-}
-
-ListViewText::ListViewText(guint columns_count, bool editable, Gtk::SelectionMode mode)
-: m_model_columns(columns_count)
-{
-  char column_title[20];
-  
-  // Create model
-  m_model = Gtk::ListStore::create(m_model_columns);	
-  set_model(m_model);
-
-  // Append columns
-  for(guint i = 0; i < columns_count; ++i)
-  {
-    //Get text for the number:
-    sprintf(column_title, "%d", i);		
-
-    if(editable)
-      append_column_editable(column_title, m_model_columns.m_columns[i]);
-    else
-      append_column(column_title, m_model_columns.m_columns[i]);
-  }
-
-  // Set multiple or simple selection
-  get_selection()->set_mode(mode);
-}
-
-ListViewText::~ListViewText()
-{
-}
-
-void ListViewText::set_column_title(guint column, const Glib::ustring& title)
-{
-  g_return_if_fail( column < get_columns().size() );
-
-  get_column(column)->set_title(title);
-}
-
-Glib::ustring ListViewText::get_column_title(guint column) const
-{
-  g_return_val_if_fail( column < get_columns().size(), "" ); //Using Glib::ustring() fails sometimes: Bug #352226
-
-  return get_column(column)->get_title();
-}
-
-guint ListViewText::append_text(const Glib::ustring& column_one_value)
-{
-  Gtk::TreeModel::Row newRow = *(m_model->append());
-
-  newRow[m_model_columns.m_columns[0]] = column_one_value;
-
-  return size() - 1;
-}
-
-void ListViewText::prepend_text(const Glib::ustring& column_one_value)
-{
-  Gtk::TreeModel::Row newRow = *(m_model->prepend());
-
-  newRow[m_model_columns.m_columns[0]] = column_one_value;
-}
-
-void ListViewText::insert_text(guint row, const Glib::ustring& column_one_value)
-{
-  g_return_if_fail( row < size() );
-
-  Gtk::ListStore::const_iterator iter = m_model->children()[row];
-  Gtk::TreeModel::Row newRow = *(m_model->insert(iter));
-
-  if(!column_one_value.empty())
-  {
-    newRow[m_model_columns.m_columns[0]] = column_one_value;
-  }
-}
-
-void ListViewText::clear_items()
-{
-  m_model->clear();
-}
-
-Glib::ustring ListViewText::get_text(guint row, guint column) const
-{
-  Glib::ustring result;
-
-  g_return_val_if_fail( row < size(), result );
-
-  Gtk::TreeModel::iterator iter = m_model->children()[row];	 
-  iter->get_value(column, result);
-
-  return result;
-}
-
-void ListViewText::set_text(guint row, guint column, const Glib::ustring& value)
-{
-  g_return_if_fail( row < size() );
-
-  Gtk::TreeModel::iterator iter = m_model->children()[row];
-  (*iter)->set_value(column, value);
-}
-
-void ListViewText::set_text(guint row, const Glib::ustring& value)
-{
-  g_return_if_fail( row < size() );
-
-  Gtk::TreeModel::iterator iter = m_model->children()[ row ];
-  (*iter)->set_value(0, value);
-}
-
-guint ListViewText::size() const
-{
-  return (guint)m_model->children().size();
-}
-
-guint ListViewText::get_num_columns() const
-{
-  return m_model_columns.get_num_columns();
-}
-
-ListViewText::SelectionList ListViewText::get_selected()
-{
-  Glib::RefPtr<Gtk::TreeSelection> selected = get_selection();
-  Gtk::TreeSelection::ListHandle_Path selectedRows = selected->get_selected_rows();
-
-  // Reserve space
-  SelectionList selectionList;
-  selectionList.reserve( selected->count_selected_rows() );
-
-  // Save selected rows
-
-  for(Gtk::TreeSelection::ListHandle_Path::const_iterator iter = selectedRows.begin(); iter != selectedRows.end(); ++iter)
-  {
-    selectionList.push_back( *((*iter).begin()) );
-  }
-
-  return selectionList;
-}
-
-} //namespace Gtk
-
diff --git a/libs/gtkmm2/gtk/gtkmm/listviewtext.h b/libs/gtkmm2/gtk/gtkmm/listviewtext.h
deleted file mode 100644
index b8236abcdc..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/listviewtext.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/* Copyright(C) 2006 The gtkmm 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.
- */
-
-#ifndef _GTKMM_LISTVIEW_TEXT_H
-#define _GTKMM_LISTVIEW_TEXT_H
-
-#include <gtkmm/treeview.h>
-#include <gtkmm/liststore.h>
-
-#include <vector>
-
-namespace Gtk
-{
-
-/** A simple listbox which presents some lines of information in columns and lets the user select some of them.
- *
- * This is a convenience class, based on Gtk::TreeView, which allows only text values and does not allow child items.
- * In most cases you will actually need the functionality offered by a real Gtk::TreeView with your own type-safe 
- * Gtk::TreeModel::ColumnRecord.
- *
- * @ingroup Widgets
- * @ingroup Containers
- * @ingroup TreeView
- *
- * @newin2p10
- */
-class ListViewText : public Gtk::TreeView
-{
-public:
-
-  ListViewText(guint columns_count, bool editable = false, Gtk::SelectionMode mode = Gtk::SELECTION_SINGLE);
-  virtual ~ListViewText();
-
-  /** Adds a title to column @a column.
-   * @param column the column number.
-   * @param title the title for column @a column.
-   */
-  void set_column_title(guint column, const Glib::ustring& title);
-
-  /** Gets the title of column @a column.
-   * @param column the column number.
-   * @return the title of column @a column.
-   */
-  Glib::ustring get_column_title(guint column) const;
-
-  /** Add a new row at the end of the list
-   * @param column_one_value the new text for the new row, column 0
-   * @return the number of the row added
-   */
-  guint append_text(const Glib::ustring& column_one_value = Glib::ustring());
-
-  /** Insert a new row at the beginning of the list
-   * @param column_one_value the new text for the new row, column 0
-   */
-  void prepend_text(const Glib::ustring& column_one_value = Glib::ustring());
-
-  /** Insert a new row at an arbitrary position in the list
-   * @param row The row number
-   * @param column_one_value the new text for the new row, column 0
-   */
-  void insert_text(guint row, const Glib::ustring& column_one_value = Glib::ustring());
-
-  /// Discard all row:
-  void clear_items();
-
-  /** Obtain the value of an existing cell from the list.
-   * @param row the number of the row in the listbox.
-   * @param column the number of the column in the row.
-   * @return the value of that cell, if it exists.
-   */
-  Glib::ustring get_text(guint row, guint column = 0) const;
-
-  /** Change an existing value of cell of the list.
-   * @param row the number of the row in the list.
-   * @param column the number of the column in the row.	 
-   * @param value the new contents of that row and column.
-   */
-  void set_text(guint row, guint column, const Glib::ustring& value);
-
-  /** Change an existing value of a column 0 of a row of the list
-   * @param row the number of the row in the list.
-   * @param value the new contents of column 0 of the row.
-   */
-  void set_text(guint row, const Glib::ustring& value);
-
-  /// @return the number of rows in the listbox
-  guint size() const;
-
-  /// @return the number of columns in the listbox
-  guint get_num_columns() const;
-
-  typedef std::vector<int> SelectionList;
-
-  /** Returns a vector of the indexes of the selected rows
-    * @return a SelectionList with the selection results
-    */
-  SelectionList get_selected();
-
-protected:
-
- class TextModelColumns : public Gtk::TreeModel::ColumnRecord
-  {
-  public:
-    TextModelColumns(guint columns_count);
-    ~TextModelColumns();
-
-    guint get_num_columns() const;
-
-    Gtk::TreeModelColumn<Glib::ustring>* m_columns;
-
-  protected:
-    guint m_columns_count;
-  };
-
-  Glib::RefPtr<Gtk::ListStore> m_model;
-  TextModelColumns m_model_columns;
-};
-
-} //namespace Gtk
-
-#endif //_GTKMM_LISTVIEW_TEXT_H
-
diff --git a/libs/gtkmm2/gtk/gtkmm/main.cc b/libs/gtkmm2/gtk/gtkmm/main.cc
index 38a9128c14..9ff2be9aa7 100644
--- a/libs/gtkmm2/gtk/gtkmm/main.cc
+++ b/libs/gtkmm2/gtk/gtkmm/main.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/main.h>
 #include <gtkmm/private/main_p.h>
 
@@ -32,9 +31,7 @@
 #include <gtkmm/window.h>
 #include <glibmm/init.h>
 #include <pangomm/wrap_init.h>
-#ifdef GTKMM_ATKMM_ENABLED
 #include <atkmm/wrap_init.h>
-#endif //GTKMM_ATKMM_ENABLED
 #include <gdkmm/wrap_init.h>
 #include <gtkmm/wrap_init.h>
 
@@ -233,20 +230,16 @@ gboolean RunSig::gtk_callback(gpointer data)
 
   if(GtkMainConnectionNode::list_remove(conn_node))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Recreate the specific SlotType from the generic slot_base.
       SlotType* pSlot = static_cast<SlotType*>(conn_node->get_slot());
       (*pSlot)();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
 
     // We don't need it anymore, since RunSig is a one-shot signal.
     GtkMainConnectionNode::destroy_notify_handler(conn_node);
@@ -274,22 +267,17 @@ sigc::connection QuitSig::connect(const QuitSig::SlotType& slot, guint main_leve
 // static
 gboolean QuitSig::gtk_callback(gpointer data)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     // Call the slot:
     GtkMainConnectionNode* node = static_cast<GtkMainConnectionNode*>(data);
     SlotType* pSlot = static_cast<SlotType*>(node->get_slot());
     (*pSlot)();
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
   return 0;
 }
 
@@ -310,22 +298,17 @@ sigc::connection KeySnooperSig::connect(const KeySnooperSig::SlotType& slot)
 // static
 gint KeySnooperSig::gtk_callback(GtkWidget* widget, GdkEventKey* event, gpointer data)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     // Recreate the specific SlotType from the generic slot node.
     GtkMainConnectionNode* conn_node = static_cast<GtkMainConnectionNode*>(data);
     SlotType* pSlot = static_cast<SlotType*>(conn_node->get_slot());
     return (*pSlot)(Glib::wrap(widget), event);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
   return 0;
 }
 
@@ -378,10 +361,7 @@ Main::~Main()
     instance_ = 0;
     GtkMainConnectionNode::list_notify_all();
 
-    // Release the gtkmm type registration tables,
-    // allowing Main to be instantiated again:
-    Glib::wrap_register_cleanup();
-    Glib::Error::register_cleanup();
+    Glib::init();
   }
 }
 
@@ -420,16 +400,7 @@ Main::Main(int& argc, char**& argv, Glib::OptionContext& option_context)
     //without calling check_setugid(), because that is not public API.
 
     add_gtk_option_group(option_context);
-
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     option_context.parse(argc, argv);
-    #else
-    std::auto_ptr<Glib::Error> ex;
-    option_context.parse(argc, argv, ex);
-    //if(ex.get())
-    //  std::cerr << ex->what() << std::endl;
-    //TODO: Pass the ex up to the caller?
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
@@ -449,9 +420,7 @@ void Main::init_gtkmm_internals()
 
     // Populate the map of GTypes to C++ wrap_new() functions.
     Pango::wrap_init();
-#ifdef GTKMM_ATKMM_ENABLED
     Atk::wrap_init();
-#endif //GTKMM_ATKMM_ENABLED
     Gdk::wrap_init();
     Gtk::wrap_init();
 
diff --git a/libs/gtkmm2/gtk/gtkmm/main.h b/libs/gtkmm2/gtk/gtkmm/main.h
index 8177b2d66e..027cbeff07 100644
--- a/libs/gtkmm2/gtk/gtkmm/main.h
+++ b/libs/gtkmm2/gtk/gtkmm/main.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MAIN_H
 #define _GTKMM_MAIN_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -119,7 +118,7 @@ public:
   /** Scans the argument vector, and strips off all parameters parsed by GTK+ or your @a option_context.
    * Add a Glib::OptionGroup to the Glib::OptionContext to parse your own command-line arguments.  
    *
-   * Note:  The argument strings themself won't be modified, although the
+   * Note:  The argument strings themselves won't be modified, although the
    * pointers to them might change.  This makes it possible to create your
    * own argv of string literals, which have the type 'const char[]' in
    * standard C++.  (You might need to use const_cast<>, though.)
diff --git a/libs/gtkmm2/gtk/gtkmm/menu.cc b/libs/gtkmm2/gtk/gtkmm/menu.cc
index c8bd5b3e47..9fdc254a21 100644
--- a/libs/gtkmm2/gtk/gtkmm/menu.cc
+++ b/libs/gtkmm2/gtk/gtkmm/menu.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/menu.h>
 #include <gtkmm/private/menu_p.h>
 
@@ -29,48 +28,76 @@
 #include <gtkmm/accelgroup.h>
 
 
-static void SignalProxy_PopupPosition_gtk_callback(GtkMenu*, int* x, int* y, gboolean* push_in, void* data)
+namespace
 {
-  Gtk::Menu::SlotPositionCalc* the_slot = static_cast<Gtk::Menu::SlotPositionCalc*>(data);
+
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_PopupPosition
+{
+public:
+  typedef Gtk::Menu::SlotPositionCalc SlotType;
+
+  SignalProxy_PopupPosition(const SlotType& slot);
+  ~SignalProxy_PopupPosition();
+
+  static void gtk_callback(GtkMenu* menu, int* x, int* y, gboolean* push_in, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_PopupPosition::SignalProxy_PopupPosition(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_PopupPosition::~SignalProxy_PopupPosition()
+{}
+
+void SignalProxy_PopupPosition::gtk_callback(GtkMenu*, int* x, int* y, gboolean* push_in, void* data)
+{
+  SignalProxy_PopupPosition *const self = static_cast<SignalProxy_PopupPosition*>(data);
 
   int  temp_x = (x) ? *x : 0;
   int  temp_y = (y) ? *y : 0;
   bool temp_push_in = (push_in) ? bool(*push_in) : false;
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    (*the_slot)(temp_x, temp_y, temp_push_in);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)(temp_x, temp_y, temp_push_in);
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   if(x) *x = temp_x;
   if(y) *y = temp_y;
   if(push_in) *push_in = temp_push_in;
 }
 
+} // anonymous namespace
+
 
 namespace Gtk
 {
 
 void Menu::popup(const SlotPositionCalc& position_calc_slot, guint button, guint32 activate_time)
 {
-  // Tell GTK+ to call the static function with the slot's address as the extra
+  SignalProxy_PopupPosition proxy(position_calc_slot);
+
+  // Tell GTK+ to call the static function with Proxy's address as the extra
   // data, so that the static function can then call the sigc::slot:
-  gtk_menu_popup(gobj(), 0, 0, &SignalProxy_PopupPosition_gtk_callback, const_cast<SlotPositionCalc*>(&position_calc_slot), button, activate_time);
+  gtk_menu_popup(gobj(), 0, 0, &SignalProxy_PopupPosition::gtk_callback, &proxy, button, activate_time);
 }
 
 void Menu::popup(MenuShell& parent_menu_shell, MenuItem& parent_menu_item, const SlotPositionCalc& position_calc_slot, guint button, guint32 activate_time)
 {
-  // Tell GTK+ to call the static function with the slot's address as the extra
+  SignalProxy_PopupPosition proxy(position_calc_slot);
+
+  // Tell GTK+ to call the static function with Proxy's address as the extra
   // data, so that the static function can then call the sigc::slot:
-  gtk_menu_popup(gobj(), parent_menu_shell.Gtk::Widget::gobj(), parent_menu_item.Gtk::Widget::gobj(), &SignalProxy_PopupPosition_gtk_callback, const_cast<SlotPositionCalc*>(&position_calc_slot), button, activate_time);
+  gtk_menu_popup(gobj(), parent_menu_shell.Gtk::Widget::gobj(), parent_menu_item.Gtk::Widget::gobj(), &SignalProxy_PopupPosition::gtk_callback, &proxy, button, activate_time);
 }
 
 void Menu::popup(guint button, guint32 activate_time)
@@ -96,12 +123,6 @@ void Menu::unset_title()
   gtk_menu_set_title(gobj(), 0);
 }
 
-void Menu::attach_to_widget(Widget& attach_widget)
-{
-  gtk_menu_attach_to_widget(gobj(), (attach_widget).gobj(), 0 /* allowed by the C docs. */);
-}
-
-
 } // namespace Gtk
 
 
@@ -151,19 +172,8 @@ void Menu_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Menu_Class::wrap_new(GObject* o)
 {
@@ -213,12 +223,12 @@ Menu::Menu()
 
 void Menu::reposition()
 {
-gtk_menu_reposition(gobj()); 
+  gtk_menu_reposition(gobj());
 }
 
 void Menu::popdown()
 {
-gtk_menu_popdown(gobj()); 
+  gtk_menu_popdown(gobj());
 }
 
 MenuItem* Menu::get_active()
@@ -228,42 +238,47 @@ MenuItem* Menu::get_active()
 
 const MenuItem* Menu::get_active() const
 {
-  return const_cast<Menu*>(this)->get_active();
+  return Glib::wrap((GtkMenuItem*)(gtk_menu_get_active(const_cast<GtkMenu*>(gobj()))));
 }
 
 void Menu::set_active(guint index)
 {
-gtk_menu_set_active(gobj(), index); 
+  gtk_menu_set_active(gobj(), index);
 }
 
 void Menu::set_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
 {
-gtk_menu_set_accel_group(gobj(), Glib::unwrap(accel_group)); 
+  gtk_menu_set_accel_group(gobj(), Glib::unwrap(accel_group));
 }
 
 Glib::RefPtr<AccelGroup> Menu::get_accel_group()
 {
 
   Glib::RefPtr<AccelGroup> retvalue = Glib::wrap(gtk_menu_get_accel_group(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const AccelGroup> Menu::get_accel_group() const
 {
-  return const_cast<Menu*>(this)->get_accel_group();
+
+  Glib::RefPtr<const AccelGroup> retvalue = Glib::wrap(gtk_menu_get_accel_group(const_cast<GtkMenu*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Menu::set_accel_path(const Glib::ustring& accel_path)
 {
-gtk_menu_set_accel_path(gobj(), accel_path.c_str()); 
+  gtk_menu_set_accel_path(gobj(), accel_path.c_str());
 }
 
 void Menu::detach()
 {
-gtk_menu_detach(gobj()); 
+  gtk_menu_detach(gobj());
 }
 
 Widget* Menu::get_attach_widget()
@@ -273,12 +288,12 @@ Widget* Menu::get_attach_widget()
 
 const Widget* Menu::get_attach_widget() const
 {
-  return const_cast<Menu*>(this)->get_attach_widget();
+  return Glib::wrap(gtk_menu_get_attach_widget(const_cast<GtkMenu*>(gobj())));
 }
 
 void Menu::set_tearoff_state(bool torn_off)
 {
-gtk_menu_set_tearoff_state(gobj(), static_cast<int>(torn_off)); 
+  gtk_menu_set_tearoff_state(gobj(), static_cast<int>(torn_off));
 }
 
 bool Menu::get_tearoff_state() const
@@ -288,7 +303,7 @@ bool Menu::get_tearoff_state() const
 
 void Menu::set_title(const Glib::ustring& title)
 {
-gtk_menu_set_title(gobj(), title.c_str()); 
+  gtk_menu_set_title(gobj(), title.c_str());
 }
 
 Glib::ustring Menu::get_title() const
@@ -298,45 +313,34 @@ Glib::ustring Menu::get_title() const
 
 void Menu::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
 {
-gtk_menu_set_screen(gobj(), Glib::unwrap(screen)); 
+  gtk_menu_set_screen(gobj(), Glib::unwrap(screen));
 }
 
 void Menu::attach(Gtk::Widget& child, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach)
 {
-gtk_menu_attach(gobj(), (child).gobj(), left_attach, right_attach, top_attach, bottom_attach); 
+  gtk_menu_attach(gobj(), (child).gobj(), left_attach, right_attach, top_attach, bottom_attach);
 }
 
 void Menu::set_monitor(int monitor_num)
 {
-gtk_menu_set_monitor(gobj(), monitor_num); 
+  gtk_menu_set_monitor(gobj(), monitor_num);
 }
 
-void Menu::attach_to_widget(Widget& attach_widget, GtkMenuDetachFunc detacher)
+void Menu::attach_to_widget(Widget& widget, GtkMenuDetachFunc detacher)
 {
-gtk_menu_attach_to_widget(gobj(), (attach_widget).gobj(), detacher); 
+  gtk_menu_attach_to_widget(gobj(), (widget).gobj(), detacher);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Menu::property_tearoff_title() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "tearoff-title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Menu::property_tearoff_title() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "tearoff-title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/menu.h b/libs/gtkmm2/gtk/gtkmm/menu.h
index a9f48ce3ee..26e78721be 100644
--- a/libs/gtkmm2/gtk/gtkmm/menu.h
+++ b/libs/gtkmm2/gtk/gtkmm/menu.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MENU_H
 #define _GTKMM_MENU_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -97,17 +96,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -225,7 +218,7 @@ public:
   
   /** Sets the Gdk::Screen on which the menu will be displayed.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param screen A Gdk::Screen, or <tt>0</tt> if the screen should be
    * determined by the widget the menu is attached to.
    */
@@ -240,7 +233,7 @@ public:
    * 
    * Note that this function is not related to detach().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param child A Gtk::MenuItem.
    * @param left_attach The column number to attach the left side of the item to.
    * @param right_attach The column number to attach the right side of the item to.
@@ -259,7 +252,7 @@ public:
    * by a Gtk::MenuPositionFunc, since, for very long menus, these coordinates 
    * may extend beyond the monitor boundaries or even the screen boundaries. 
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param monitor_num The number of the monitor on which the menu should
    * be popped up.
    */
@@ -268,17 +261,14 @@ public:
   void reorder_child(const MenuItem& child, int position);
   
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A title that may be displayed by the window manager when this menu is torn-off.
+  /** A title that may be displayed by the window manager when this menu is torn-off.
    *
    * 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_tearoff_title() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** A title that may be displayed by the window manager when this menu is torn-off.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -286,7 +276,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_tearoff_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -294,16 +283,7 @@ protected:
   //We can not wrap this as a slot because there is no data parameter, and no destroy callback to destroy that data.
   typedef void (*GtkMenuDetachFunc)   (GtkWidget *attach_widget, GtkMenu   *menu);
   
-  void attach_to_widget(Widget& attach_widget, GtkMenuDetachFunc detacher);
-
-  //TODO: What does "attach" actually mean here? murrayc
-  /** Attaches the menu to the widget.
-   * 
-   * param @attach_widget: the Widget that the menu will be attached to.
-   *
-   * @newin2p10
-   */
-  void attach_to_widget(Widget& attach_widget);
+  void attach_to_widget(Widget& widget, GtkMenuDetachFunc detacher);
 
 
 };
@@ -319,8 +299,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Menu* wrap(GtkMenu* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_MENU_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/menubar.cc b/libs/gtkmm2/gtk/gtkmm/menubar.cc
index fc7e849af0..8b5ef04bbc 100644
--- a/libs/gtkmm2/gtk/gtkmm/menubar.cc
+++ b/libs/gtkmm2/gtk/gtkmm/menubar.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/menubar.h>
 #include <gtkmm/private/menubar_p.h>
 
@@ -101,19 +100,8 @@ void MenuBar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* MenuBar_Class::wrap_new(GObject* o)
 {
@@ -154,13 +142,6 @@ GType MenuBar::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/menubar.h b/libs/gtkmm2/gtk/gtkmm/menubar.h
index c636a12e93..f7d8dea03e 100644
--- a/libs/gtkmm2/gtk/gtkmm/menubar.h
+++ b/libs/gtkmm2/gtk/gtkmm/menubar.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MENUBAR_H
 #define _GTKMM_MENUBAR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -92,17 +91,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -130,8 +123,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::MenuBar* wrap(GtkMenuBar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_MENUBAR_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/menuitem.cc b/libs/gtkmm2/gtk/gtkmm/menuitem.cc
index 8a7892a6fa..44f86a9204 100644
--- a/libs/gtkmm2/gtk/gtkmm/menuitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/menuitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/menuitem.h>
 #include <gtkmm/private/menuitem_p.h>
 
@@ -63,12 +62,7 @@ void MenuItem::add_accel_label(const Glib::ustring& label, bool mnemonic)
 {
   AccelLabel* pLabel = manage(new AccelLabel(label, mnemonic));
   //Labels are centered by default, but in menus they should be left-aligned.
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-  pLabel->property_xalign() = 0.0;
-  #else
-  pLabel->set_property("xalign", 0.0f);
-  #endif //GLIBMM_PROPERTIES_ENABLED
+  pLabel->property_xalign() = 0.0; 
 
   add(*pLabel);
 
@@ -123,8 +117,7 @@ void MenuItem::unset_accel_path()
 namespace
 {
 
-
-static const Glib::SignalProxyInfo MenuItem_signal_activate_info =
+const Glib::SignalProxyInfo MenuItem_signal_activate_info =
 {
   "activate",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -132,7 +125,7 @@ static const Glib::SignalProxyInfo MenuItem_signal_activate_info =
 };
 
 
-static const Glib::SignalProxyInfo MenuItem_signal_activate_item_info =
+const Glib::SignalProxyInfo MenuItem_signal_activate_item_info =
 {
   "activate_item",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -140,7 +133,7 @@ static const Glib::SignalProxyInfo MenuItem_signal_activate_item_info =
 };
 
 
-static void MenuItem_signal_toggle_size_request_callback(GtkMenuItem* self, int* p0,void* data)
+void MenuItem_signal_toggle_size_request_callback(GtkMenuItem* self, int* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,int* > SlotType;
@@ -148,23 +141,19 @@ static void MenuItem_signal_toggle_size_request_callback(GtkMenuItem* self, int*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo MenuItem_signal_toggle_size_request_info =
+const Glib::SignalProxyInfo MenuItem_signal_toggle_size_request_info =
 {
   "toggle_size_request",
   (GCallback) &MenuItem_signal_toggle_size_request_callback,
@@ -172,7 +161,7 @@ static const Glib::SignalProxyInfo MenuItem_signal_toggle_size_request_info =
 };
 
 
-static void MenuItem_signal_toggle_size_allocate_callback(GtkMenuItem* self, gint p0,void* data)
+void MenuItem_signal_toggle_size_allocate_callback(GtkMenuItem* self, gint p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,int > SlotType;
@@ -180,31 +169,26 @@ static void MenuItem_signal_toggle_size_allocate_callback(GtkMenuItem* self, gin
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo MenuItem_signal_toggle_size_allocate_info =
+const Glib::SignalProxyInfo MenuItem_signal_toggle_size_allocate_info =
 {
   "toggle_size_allocate",
   (GCallback) &MenuItem_signal_toggle_size_allocate_callback,
   (GCallback) &MenuItem_signal_toggle_size_allocate_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -249,21 +233,13 @@ void MenuItem_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->activate = &activate_callback;
   klass->activate_item = &activate_item_callback;
   klass->toggle_size_request = &toggle_size_request_callback;
   klass->toggle_size_allocate = &toggle_size_allocate_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void MenuItem_Class::activate_callback(GtkMenuItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -276,19 +252,15 @@ void MenuItem_Class::activate_callback(GtkMenuItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_activate();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -301,6 +273,7 @@ void MenuItem_Class::activate_callback(GtkMenuItem* self)
       (*base->activate)(self);
   }
 }
+
 void MenuItem_Class::activate_item_callback(GtkMenuItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -313,19 +286,15 @@ void MenuItem_Class::activate_item_callback(GtkMenuItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_activate_item();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -338,6 +307,7 @@ void MenuItem_Class::activate_item_callback(GtkMenuItem* self)
       (*base->activate_item)(self);
   }
 }
+
 void MenuItem_Class::toggle_size_request_callback(GtkMenuItem* self, int* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -350,19 +320,15 @@ void MenuItem_Class::toggle_size_request_callback(GtkMenuItem* self, int* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggle_size_request(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -375,6 +341,7 @@ void MenuItem_Class::toggle_size_request_callback(GtkMenuItem* self, int* p0)
       (*base->toggle_size_request)(self, p0);
   }
 }
+
 void MenuItem_Class::toggle_size_allocate_callback(GtkMenuItem* self, gint p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -387,20 +354,16 @@ void MenuItem_Class::toggle_size_allocate_callback(GtkMenuItem* self, gint p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggle_size_allocate(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -413,7 +376,6 @@ void MenuItem_Class::toggle_size_allocate_callback(GtkMenuItem* self, gint p0)
       (*base->toggle_size_allocate)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* MenuItem_Class::wrap_new(GObject* o)
@@ -464,7 +426,7 @@ MenuItem::MenuItem()
 
 void MenuItem::set_submenu(Menu& submenu)
 {
-gtk_menu_item_set_submenu(gobj(), (submenu).Gtk::Widget::gobj()); 
+  gtk_menu_item_set_submenu(gobj(), (submenu).Gtk::Widget::gobj());
 }
 
 Menu* MenuItem::get_submenu()
@@ -474,42 +436,42 @@ Menu* MenuItem::get_submenu()
 
 const Menu* MenuItem::get_submenu() const
 {
-  return const_cast<MenuItem*>(this)->get_submenu();
+  return Glib::wrap((GtkMenu*)(gtk_menu_item_get_submenu(const_cast<GtkMenuItem*>(gobj()))));
 }
 
 void MenuItem::remove_submenu()
 {
-gtk_menu_item_remove_submenu(gobj()); 
+  gtk_menu_item_remove_submenu(gobj());
 }
 
 void MenuItem::select()
 {
-gtk_menu_item_select(gobj()); 
+  gtk_menu_item_select(gobj());
 }
 
 void MenuItem::deselect()
 {
-gtk_menu_item_deselect(gobj()); 
+  gtk_menu_item_deselect(gobj());
 }
 
 void MenuItem::activate()
 {
-gtk_menu_item_activate(gobj()); 
+  gtk_menu_item_activate(gobj());
 }
 
 void MenuItem::toggle_size_request(int& requisition)
 {
-gtk_menu_item_toggle_size_request(gobj(), &requisition); 
+  gtk_menu_item_toggle_size_request(gobj(), &requisition);
 }
 
 void MenuItem::toggle_size_allocate(int allocation)
 {
-gtk_menu_item_toggle_size_allocate(gobj(), allocation); 
+  gtk_menu_item_toggle_size_allocate(gobj(), allocation);
 }
 
 void MenuItem::set_right_justified(bool right_justified)
 {
-gtk_menu_item_set_right_justified(gobj(), static_cast<int>(right_justified)); 
+  gtk_menu_item_set_right_justified(gobj(), static_cast<int>(right_justified));
 }
 
 bool MenuItem::get_right_justified() const
@@ -519,7 +481,7 @@ bool MenuItem::get_right_justified() const
 
 void MenuItem::set_accel_path(const Glib::ustring& accel_path)
 {
-gtk_menu_item_set_accel_path(gobj(), accel_path.c_str()); 
+  gtk_menu_item_set_accel_path(gobj(), accel_path.c_str());
 }
 
 
@@ -528,26 +490,22 @@ Glib::SignalProxy0< void > MenuItem::signal_activate()
   return Glib::SignalProxy0< void >(this, &MenuItem_signal_activate_info);
 }
 
-
 Glib::SignalProxy0< void > MenuItem::signal_activate_item()
 {
   return Glib::SignalProxy0< void >(this, &MenuItem_signal_activate_item_info);
 }
 
-
 Glib::SignalProxy1< void,int* > MenuItem::signal_toggle_size_request()
 {
   return Glib::SignalProxy1< void,int* >(this, &MenuItem_signal_toggle_size_request_info);
 }
 
-
 Glib::SignalProxy1< void,int > MenuItem::signal_toggle_size_allocate()
 {
   return Glib::SignalProxy1< void,int >(this, &MenuItem_signal_toggle_size_allocate_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::MenuItem::on_activate()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -557,6 +515,7 @@ void Gtk::MenuItem::on_activate()
   if(base && base->activate)
     (*base->activate)(gobj());
 }
+
 void Gtk::MenuItem::on_activate_item()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -566,6 +525,7 @@ void Gtk::MenuItem::on_activate_item()
   if(base && base->activate_item)
     (*base->activate_item)(gobj());
 }
+
 void Gtk::MenuItem::on_toggle_size_request(int* requisition)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -575,6 +535,7 @@ void Gtk::MenuItem::on_toggle_size_request(int* requisition)
   if(base && base->toggle_size_request)
     (*base->toggle_size_request)(gobj(),requisition);
 }
+
 void Gtk::MenuItem::on_toggle_size_allocate(int allocation)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -584,10 +545,6 @@ void Gtk::MenuItem::on_toggle_size_allocate(int allocation)
   if(base && base->toggle_size_allocate)
     (*base->toggle_size_allocate)(gobj(),allocation);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/menuitem.h b/libs/gtkmm2/gtk/gtkmm/menuitem.h
index 1e5bb18c6a..50e2ccc610 100644
--- a/libs/gtkmm2/gtk/gtkmm/menuitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/menuitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MENUITEM_H
 #define _GTKMM_MENUITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -97,21 +96,15 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_activate();
   virtual void on_activate_item();
   virtual void on_toggle_size_request(int* requisition);
   virtual void on_toggle_size_allocate(int allocation);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -194,35 +187,15 @@ public:
   void unset_accel_path();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %activate()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_activate();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %activate_item()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_activate_item();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %toggle_size_request(int* requisition)</tt>
-   */
-
   Glib::SignalProxy1< void,int* > signal_toggle_size_request();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %toggle_size_allocate(int allocation)</tt>
-   */
-
   Glib::SignalProxy1< void,int > signal_toggle_size_allocate();
 
 
@@ -255,8 +228,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::MenuItem* wrap(GtkMenuItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_MENUITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/menushell.cc b/libs/gtkmm2/gtk/gtkmm/menushell.cc
index 3eb5a103d5..60cc879572 100644
--- a/libs/gtkmm2/gtk/gtkmm/menushell.cc
+++ b/libs/gtkmm2/gtk/gtkmm/menushell.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/menushell.h>
 #include <gtkmm/private/menushell_p.h>
 
@@ -92,10 +91,8 @@ const MenuShell::MenuList& MenuShell::items() const
 
 void MenuShell_Class::insert_vfunc_callback(GtkMenuShell* self, GtkWidget* child, int position)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     MenuShell *const obj = dynamic_cast<MenuShell*>(
         Glib::ObjectBase::_get_current_wrapper((GObject*) self));
 
@@ -104,13 +101,11 @@ void MenuShell_Class::insert_vfunc_callback(GtkMenuShell* self, GtkWidget* child
     {
       Glib::wrap((GtkMenuItem*) child)->accelerate(*obj->accel_window_);
     }
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   GtkMenuShellClass *const base = static_cast<GtkMenuShellClass*>(
       g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)));
@@ -210,8 +205,7 @@ MenuList::iterator MenuList::erase(iterator position)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo MenuShell_signal_deactivate_info =
+const Glib::SignalProxyInfo MenuShell_signal_deactivate_info =
 {
   "deactivate",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -219,14 +213,13 @@ static const Glib::SignalProxyInfo MenuShell_signal_deactivate_info =
 };
 
 
-static const Glib::SignalProxyInfo MenuShell_signal_selection_done_info =
+const Glib::SignalProxyInfo MenuShell_signal_selection_done_info =
 {
   "selection_done",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -271,20 +264,12 @@ void MenuShell_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
     klass->insert = &insert_vfunc_callback;
-  #endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->deactivate = &deactivate_callback;
+    klass->deactivate = &deactivate_callback;
   klass->selection_done = &selection_done_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void MenuShell_Class::deactivate_callback(GtkMenuShell* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -297,19 +282,15 @@ void MenuShell_Class::deactivate_callback(GtkMenuShell* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_deactivate();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -322,6 +303,7 @@ void MenuShell_Class::deactivate_callback(GtkMenuShell* self)
       (*base->deactivate)(self);
   }
 }
+
 void MenuShell_Class::selection_done_callback(GtkMenuShell* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -334,19 +316,15 @@ void MenuShell_Class::selection_done_callback(GtkMenuShell* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_selection_done();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -359,7 +337,6 @@ void MenuShell_Class::selection_done_callback(GtkMenuShell* self)
       (*base->selection_done)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* MenuShell_Class::wrap_new(GObject* o)
@@ -434,57 +411,47 @@ MenuList::reference MenuList::operator[](size_type l) const
 
 void MenuShell::append(MenuItem& menu_item)
 {
-gtk_menu_shell_append(gobj(), (menu_item).Gtk::Widget::gobj()); 
+  gtk_menu_shell_append(gobj(), (menu_item).Gtk::Widget::gobj());
 }
 
 void MenuShell::prepend(MenuItem& menu_item)
 {
-gtk_menu_shell_prepend(gobj(), (menu_item).Gtk::Widget::gobj()); 
+  gtk_menu_shell_prepend(gobj(), (menu_item).Gtk::Widget::gobj());
 }
 
 void MenuShell::insert(MenuItem& menu_item, int position)
 {
-gtk_menu_shell_insert(gobj(), (menu_item).Gtk::Widget::gobj(), position); 
+  gtk_menu_shell_insert(gobj(), (menu_item).Gtk::Widget::gobj(), position);
 }
 
 void MenuShell::select_item(MenuItem& menu_item)
 {
-gtk_menu_shell_select_item(gobj(), (menu_item).Gtk::Widget::gobj()); 
+  gtk_menu_shell_select_item(gobj(), (menu_item).Gtk::Widget::gobj());
 }
 
 void MenuShell::deselect()
 {
-gtk_menu_shell_deselect(gobj()); 
+  gtk_menu_shell_deselect(gobj());
 }
 
 void MenuShell::activate_item(MenuItem& menu_item, bool force_deactivate)
 {
-gtk_menu_shell_activate_item(gobj(), (menu_item).Gtk::Widget::gobj(), static_cast<int>(force_deactivate)); 
+  gtk_menu_shell_activate_item(gobj(), (menu_item).Gtk::Widget::gobj(), static_cast<int>(force_deactivate));
 }
 
 void MenuShell::select_first(bool search_sensitive)
 {
-gtk_menu_shell_select_first(gobj(), static_cast<int>(search_sensitive)); 
+  gtk_menu_shell_select_first(gobj(), static_cast<int>(search_sensitive));
 }
 
 void MenuShell::deactivate()
 {
-gtk_menu_shell_deactivate(gobj()); 
+  gtk_menu_shell_deactivate(gobj());
 }
 
 void MenuShell::cancel()
 {
-gtk_menu_shell_cancel(gobj()); 
-}
-
-bool MenuShell::get_take_focus() const
-{
-  return gtk_menu_shell_get_take_focus(const_cast<GtkMenuShell*>(gobj()));
-}
-
-void MenuShell::set_take_focus(bool take_focus)
-{
-gtk_menu_shell_set_take_focus(gobj(), static_cast<int>(take_focus)); 
+  gtk_menu_shell_cancel(gobj());
 }
 
 
@@ -493,29 +460,12 @@ Glib::SignalProxy0< void > MenuShell::signal_deactivate()
   return Glib::SignalProxy0< void >(this, &MenuShell_signal_deactivate_info);
 }
 
-
 Glib::SignalProxy0< void > MenuShell::signal_selection_done()
 {
   return Glib::SignalProxy0< void >(this, &MenuShell_signal_selection_done_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> MenuShell::property_take_focus() 
-{
-  return Glib::PropertyProxy<bool>(this, "take-focus");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> MenuShell::property_take_focus() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "take-focus");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::MenuShell::on_deactivate()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -525,6 +475,7 @@ void Gtk::MenuShell::on_deactivate()
   if(base && base->deactivate)
     (*base->deactivate)(gobj());
 }
+
 void Gtk::MenuShell::on_selection_done()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -534,10 +485,6 @@ void Gtk::MenuShell::on_selection_done()
   if(base && base->selection_done)
     (*base->selection_done)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/menushell.h b/libs/gtkmm2/gtk/gtkmm/menushell.h
index 8a69512bf6..c5ad744828 100644
--- a/libs/gtkmm2/gtk/gtkmm/menushell.h
+++ b/libs/gtkmm2/gtk/gtkmm/menushell.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MENUSHELL_H
 #define _GTKMM_MENUSHELL_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -155,19 +154,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_deactivate();
   virtual void on_selection_done();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -199,7 +192,7 @@ public:
    * don't select tearoff items unless the only item is a tearoff
    * item.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param search_sensitive If <tt>true</tt>, search for the first selectable
    * menu item, otherwise select nothing if
    * the first item isn't sensitive. This
@@ -212,24 +205,14 @@ public:
   
   /** Cancels the selection within the menu shell.  
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void cancel();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %deactivate()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_deactivate();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %selection_done()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_selection_done();
 
 
@@ -276,66 +259,6 @@ public:
    */
   void accelerate(Widget& parent);
 
-  
-  /** Returns <tt>true</tt> if the menu shell will take the keyboard focus on popup.
-   * @return <tt>true</tt> if the menu shell will take the keyboard focus on popup.
-   * 
-   * @newin2p8.
-   */
-  bool get_take_focus() const;
-  
-  /** If @a take_focus  is <tt>true</tt> (the default) the menu shell will take the keyboard 
-   * focus so that it will receive all keyboard events which is needed to enable
-   * keyboard navigation in menus.
-   * 
-   * Setting @a take_focus  to <tt>false</tt> is useful only for special applications
-   * like virtual keyboard implementations which should not take keyboard
-   * focus.
-   * 
-   * The @a take_focus  state of a menu or menu bar is automatically propagated
-   * to submenus whenever a submenu is popped up, so you don't have to worry
-   * about recursively setting it for your entire menu hierarchy. Only when
-   * programmatically picking a submenu and popping it up manually, the
-   *  @a take_focus  property of the submenu needs to be set explicitely.
-   * 
-   * Note that setting it to <tt>false</tt> has side-effects:
-   * 
-   * If the focus is in some other app, it keeps the focus and keynav in
-   * the menu doesn't work. Consequently, keynav on the menu will only
-   * work if the focus is on some toplevel owned by the onscreen keyboard.
-   * 
-   * To avoid confusing the user, menus with @a take_focus  set to <tt>false</tt>
-   * should not display mnemonics or accelerators, since it cannot be
-   * guaranteed that they will work.
-   * 
-   * See also gdk_keyboard_grab()
-   * 
-   * @newin2p8
-   * @param take_focus <tt>true</tt> if the menu shell should take the keyboard focus on popup.
-   */
-  void set_take_focus(bool take_focus = true);
-  
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A boolean that determines whether the menu grabs the keyboard focus.
-   *
-   * 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_take_focus() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** A boolean that determines whether the menu grabs the keyboard focus.
-   *
-   * 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_take_focus() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
 protected:
   MenuShell();
   
@@ -360,8 +283,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::MenuShell* wrap(GtkMenuShell* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_MENUSHELL_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc
index 718dfdfb6a..8cb38dca61 100644
--- a/libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/menutoolbutton.h>
 #include <gtkmm/private/menutoolbutton_p.h>
 
@@ -51,15 +50,13 @@ MenuToolButton::MenuToolButton(Widget& icon_widget, const Glib::ustring& label)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo MenuToolButton_signal_show_menu_info =
+const Glib::SignalProxyInfo MenuToolButton_signal_show_menu_info =
 {
   "show_menu",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -104,18 +101,10 @@ void MenuToolButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->show_menu = &show_menu_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void MenuToolButton_Class::show_menu_callback(GtkMenuToolButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -128,19 +117,15 @@ void MenuToolButton_Class::show_menu_callback(GtkMenuToolButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_show_menu();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -153,7 +138,6 @@ void MenuToolButton_Class::show_menu_callback(GtkMenuToolButton* self)
       (*base->show_menu)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* MenuToolButton_Class::wrap_new(GObject* o)
@@ -211,7 +195,7 @@ MenuToolButton::MenuToolButton(const Gtk::StockID& stock_id)
 
 void MenuToolButton::set_menu(Menu& menu)
 {
-gtk_menu_tool_button_set_menu(gobj(), (menu).Gtk::Widget::gobj()); 
+  gtk_menu_tool_button_set_menu(gobj(), (menu).Gtk::Widget::gobj());
 }
 
 Menu* MenuToolButton::get_menu()
@@ -221,12 +205,12 @@ Menu* MenuToolButton::get_menu()
 
 const Menu* MenuToolButton::get_menu() const
 {
-  return const_cast<MenuToolButton*>(this)->get_menu();
+  return Glib::wrap((GtkMenu*)(gtk_menu_tool_button_get_menu(const_cast<GtkMenuToolButton*>(gobj()))));
 }
 
 void MenuToolButton::set_arrow_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private)
 {
-gtk_menu_tool_button_set_arrow_tooltip(gobj(), (tooltips).gobj(), tip_text.c_str(), tip_private.c_str()); 
+  gtk_menu_tool_button_set_arrow_tooltip(gobj(), (tooltips).gobj(), tip_text.c_str(), tip_private.c_str());
 }
 
 
@@ -236,22 +220,17 @@ Glib::SignalProxy0< void > MenuToolButton::signal_show_menu()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Menu*> MenuToolButton::property_menu() 
 {
   return Glib::PropertyProxy<Menu*>(this, "menu");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Menu*> MenuToolButton::property_menu() const
 {
   return Glib::PropertyProxy_ReadOnly<Menu*>(this, "menu");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::MenuToolButton::on_show_menu()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -261,10 +240,6 @@ void Gtk::MenuToolButton::on_show_menu()
   if(base && base->show_menu)
     (*base->show_menu)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/menutoolbutton.h b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.h
index 94ecc13dd4..a8d6be8055 100644
--- a/libs/gtkmm2/gtk/gtkmm/menutoolbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/menutoolbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MENUTOOLBUTTON_H
 #define _GTKMM_MENUTOOLBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -92,18 +91,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_show_menu();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -143,7 +136,7 @@ public:
   /** Sets the Gtk::Menu that is popped up when the user clicks on the arrow.
    * If @a menu  is <tt>0</tt>, the arrow button becomes insensitive.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param menu The Gtk::Menu associated with Gtk::MenuToolButton.
    */
   void set_menu(Menu& menu);
@@ -151,48 +144,31 @@ public:
   /** Gets the Gtk::Menu associated with Gtk::MenuToolButton.
    * @return The Gtk::Menu associated with Gtk::MenuToolButton
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Menu* get_menu();
   
   /** Gets the Gtk::Menu associated with Gtk::MenuToolButton.
    * @return The Gtk::Menu associated with Gtk::MenuToolButton
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   const Menu* get_menu() const;
 
   
-  /** Sets the Gtk::Tooltips object to be used for arrow button which
-   * pops up the menu. See Gtk::ToolItem::set_tooltip() for setting
-   * a tooltip on the whole Gtk::MenuToolButton.
-   * 
-   * @newin2p6
-   * @param tooltips The Gtk::Tooltips object to be used.
-   * @param tip_text Text to be used as tooltip text for tool_item.
-   * @param tip_private Text to be used as private tooltip text.
-   */
   void set_arrow_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %show_menu()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_show_menu();
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The dropdown menu.
+  /** The dropdown menu.
    *
    * 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<Menu*> property_menu() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The dropdown menu.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -200,7 +176,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Menu*> property_menu() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -216,8 +191,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::MenuToolButton* wrap(GtkMenuToolButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_MENUTOOLBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/messagedialog.cc b/libs/gtkmm2/gtk/gtkmm/messagedialog.cc
index cb40c6a920..4a86cc5f1f 100644
--- a/libs/gtkmm2/gtk/gtkmm/messagedialog.cc
+++ b/libs/gtkmm2/gtk/gtkmm/messagedialog.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/messagedialog.h>
 #include <gtkmm/private/messagedialog_p.h>
 
@@ -137,19 +136,8 @@ void MessageDialog_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* MessageDialog_Class::wrap_new(GObject* o)
 {
@@ -190,118 +178,10 @@ GType MessageDialog::get_base_type()
 }
 
 
-void MessageDialog::set_image(Widget& image)
-{
-gtk_message_dialog_set_image(gobj(), (image).gobj()); 
-}
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void MessageDialog::set_markup(const Glib::ustring& str)
 {
-gtk_message_dialog_set_markup(gobj(), str.c_str()); 
-}
-
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<MessageType> MessageDialog::property_message_type() 
-{
-  return Glib::PropertyProxy<MessageType>(this, "message-type");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<MessageType> MessageDialog::property_message_type() const
-{
-  return Glib::PropertyProxy_ReadOnly<MessageType>(this, "message-type");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<ButtonsType> MessageDialog::property_buttons() const
-{
-  return Glib::PropertyProxy_ReadOnly<ButtonsType>(this, "buttons");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> MessageDialog::property_text() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "text");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> MessageDialog::property_text() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> MessageDialog::property_use_markup() 
-{
-  return Glib::PropertyProxy<bool>(this, "use-markup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> MessageDialog::property_use_markup() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-markup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> MessageDialog::property_secondary_text() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "secondary-text");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> MessageDialog::property_secondary_text() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "secondary-text");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> MessageDialog::property_secondary_use_markup() 
-{
-  return Glib::PropertyProxy<bool>(this, "secondary-use-markup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> MessageDialog::property_secondary_use_markup() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "secondary-use-markup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Widget*> MessageDialog::property_image() 
-{
-  return Glib::PropertyProxy<Widget*>(this, "image");
+  gtk_message_dialog_set_markup(gobj(), str.c_str());
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Widget*> MessageDialog::property_image() const
-{
-  return Glib::PropertyProxy_ReadOnly<Widget*>(this, "image");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/messagedialog.h b/libs/gtkmm2/gtk/gtkmm/messagedialog.h
index 154d24b942..68519df606 100644
--- a/libs/gtkmm2/gtk/gtkmm/messagedialog.h
+++ b/libs/gtkmm2/gtk/gtkmm/messagedialog.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MESSAGEDIALOG_H
 #define _GTKMM_MESSAGEDIALOG_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -52,8 +51,7 @@ enum MessageType
   MESSAGE_INFO,
   MESSAGE_WARNING,
   MESSAGE_QUESTION,
-  MESSAGE_ERROR,
-  MESSAGE_OTHER
+  MESSAGE_ERROR
 };
 
 } // namespace Gtk
@@ -166,17 +164,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -187,22 +179,17 @@ public:
   MessageDialog(Gtk::Window& parent, const Glib::ustring& message, bool use_markup = false, MessageType type = MESSAGE_INFO, ButtonsType buttons = BUTTONS_OK, bool modal = false);
   
 
-  void set_image(Widget& image);
-
+  /** @deprecated Use set_message(string, true);
+   */
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
   /** Sets the text of the message dialog to be @a str , which is marked
    * up with the Pango text markup
    * language.
    * 
-   * @newin2p4
-   * @deprecated Use set_message(string, true).
+   * Since: 2.4
    * @param str Markup string (see Pango markup format).
    */
   void set_markup(const Glib::ustring& str);
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
   /** Sets the primary text of the message dialog.
    *
@@ -215,7 +202,7 @@ public:
   /** Sets the secondary text of the message dialog.
    * Note that setting a secondary text makes the primary text become bold, unless you have provided explicit markup.
    *
-   * @newin2p6.
+   * Since 2.6.
    *
    * @param text The message.
    * @param use_markup Whether @a message contains pango markup.
@@ -223,138 +210,6 @@ public:
   void set_secondary_text(const Glib::ustring& text, bool use_markup = false);
   
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The type of message.
-   *
-   * 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<MessageType> property_message_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The type of message.
-   *
-   * 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<MessageType> property_message_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The buttons shown in the message dialog.
-   *
-   * 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<ButtonsType> property_buttons() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The primary text of the message dialog.
-   *
-   * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The primary text of the message dialog.
-   *
-   * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The primary text of the title includes Pango 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<bool> property_use_markup() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The primary text of the title includes Pango 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<bool> property_use_markup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The secondary text of the message dialog.
-   *
-   * 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_secondary_text() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The secondary text of the message dialog.
-   *
-   * 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_secondary_text() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The secondary text includes Pango 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<bool> property_secondary_use_markup() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The secondary text includes Pango 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<bool> property_secondary_use_markup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The image.
-   *
-   * 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<Widget*> property_image() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The image.
-   *
-   * 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<Widget*> property_image() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
 };
 
 } // namespace Gtk
@@ -368,8 +223,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::MessageDialog* wrap(GtkMessageDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_MESSAGEDIALOG_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/misc.cc b/libs/gtkmm2/gtk/gtkmm/misc.cc
index 0d8743510c..e3b73f70c9 100644
--- a/libs/gtkmm2/gtk/gtkmm/misc.cc
+++ b/libs/gtkmm2/gtk/gtkmm/misc.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/misc.h>
 #include <gtkmm/private/misc_p.h>
 
@@ -80,19 +79,8 @@ void Misc_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Misc_Class::wrap_new(GObject* o)
 {
@@ -142,92 +130,69 @@ Misc::Misc()
 
 void Misc::set_alignment(float xalign, float yalign)
 {
-gtk_misc_set_alignment(gobj(), xalign, yalign); 
+  gtk_misc_set_alignment(gobj(), xalign, yalign);
 }
 
 void Misc::set_alignment(AlignmentEnum xalign, AlignmentEnum yalign)
 {
-gtk_misc_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign)); 
+  gtk_misc_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign), _gtkmm_align_float_from_enum(yalign));
 }
 
 void Misc::get_alignment(float& xalign, float& yalign) const
 {
-gtk_misc_get_alignment(const_cast<GtkMisc*>(gobj()), &(xalign), &(yalign)); 
+  gtk_misc_get_alignment(const_cast<GtkMisc*>(gobj()), &(xalign), &(yalign));
 }
 
 void Misc::set_padding(int xpad, int ypad)
 {
-gtk_misc_set_padding(gobj(), xpad, ypad); 
+  gtk_misc_set_padding(gobj(), xpad, ypad);
 }
 
 void Misc::get_padding(int& xpad, int& ypad) const
 {
-gtk_misc_get_padding(const_cast<GtkMisc*>(gobj()), &xpad, &ypad); 
+  gtk_misc_get_padding(const_cast<GtkMisc*>(gobj()), &xpad, &ypad);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Misc::property_xalign() 
 {
   return Glib::PropertyProxy<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Misc::property_xalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "xalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> Misc::property_yalign() 
 {
   return Glib::PropertyProxy<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> Misc::property_yalign() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "yalign");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Misc::property_xpad() 
 {
   return Glib::PropertyProxy<int>(this, "xpad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Misc::property_xpad() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "xpad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Misc::property_ypad() 
 {
   return Glib::PropertyProxy<int>(this, "ypad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Misc::property_ypad() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "ypad");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/misc.h b/libs/gtkmm2/gtk/gtkmm/misc.h
index 2edfe51010..1d1a32d794 100644
--- a/libs/gtkmm2/gtk/gtkmm/misc.h
+++ b/libs/gtkmm2/gtk/gtkmm/misc.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_MISC_H
 #define _GTKMM_MISC_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -95,17 +94,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -136,17 +129,14 @@ public:
    */
   void get_padding(int& xpad, int& ypad) const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The horizontal alignment
+  /** The horizontal alignment
    *
    * 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<float> property_xalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The horizontal alignment
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -154,19 +144,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_xalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The vertical alignment
+  /** The vertical alignment
    *
    * 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<float> property_yalign() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The vertical alignment
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -174,19 +160,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_yalign() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The amount of space to add on the left and right of the widget
+  /** The amount of space to add on the left and right of the 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<int> property_xpad() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The amount of space to add on the left and right of the widget
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -194,19 +176,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_xpad() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The amount of space to add on the top and bottom of the widget
+  /** The amount of space to add on the top and bottom of the 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<int> property_ypad() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The amount of space to add on the top and bottom of the widget
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -214,7 +192,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_ypad() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -230,8 +207,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Misc* wrap(GtkMisc* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_MISC_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/notebook.cc b/libs/gtkmm2/gtk/gtkmm/notebook.cc
index 8ba16a6d38..7ff83da6d1 100644
--- a/libs/gtkmm2/gtk/gtkmm/notebook.cc
+++ b/libs/gtkmm2/gtk/gtkmm/notebook.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/notebook.h>
 #include <gtkmm/private/notebook_p.h>
 
@@ -28,38 +27,6 @@
 #include <gtk/gtknotebook.h>
 #include <gtkmm/label.h>
 
-//We use a function instead of a static method, so we can make it static, so it is not exported.
-static GtkNotebook* SignalProxy_WindowCreation_gtk_callback(GtkNotebook* /* source */, GtkWidget* page, gint x, gint y, gpointer data)
-{
-  Gtk::Notebook::SlotWindowCreation* the_slot = static_cast<Gtk::Notebook::SlotWindowCreation*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    Gtk::Widget* pCppPage = Glib::wrap(page);
-
-    Gtk::Notebook* pCppNotebookResult = (*the_slot)(pCppPage, x, y);
-    if(pCppNotebookResult)
-      return pCppNotebookResult->gobj();
-    else
-      return 0;
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-    return 0;
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_WindowCreation_gtk_callback_destroy(void* data)
-{
-  Gtk::Notebook::SlotWindowCreation* the_slot = static_cast<Gtk::Notebook::SlotWindowCreation*>(data);
-  delete the_slot;
-}
-
 
 namespace Gtk
 {
@@ -466,27 +433,13 @@ int Notebook::insert_page(Widget& child, int position)
   return gtk_notebook_insert_page(gobj(), child.gobj(), 0 /* see GTK+ docs */, position);
 }
 
-  /** For instance,
-   * Notebook* on_window_creation(Widget* page, int x, int y);
-   */
-  typedef sigc::slot<Widget*, int, int> SlotWindowCreation;
-
-void Notebook::set_window_creation_hook(const SlotWindowCreation& slot)
-{
-  SlotWindowCreation* slot_copy = new SlotWindowCreation(slot);
-  //TODO: GTK+ needs a destroy callback so we can delete the slot later.
-  //See bug 344209
-  gtk_notebook_set_window_creation_hook(&SignalProxy_WindowCreation_gtk_callback, slot_copy, &SignalProxy_WindowCreation_gtk_callback_destroy);
-}
-
 } //namespace Gtk
 
 
 namespace
 {
 
-
-static void Notebook_signal_switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0,guint p1,void* data)
+void Notebook_signal_switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0,guint p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GtkNotebookPage*,guint > SlotType;
@@ -494,129 +447,25 @@ static void Notebook_signal_switch_page_callback(GtkNotebook* self, GtkNotebookP
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0, p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Notebook_signal_switch_page_info =
+const Glib::SignalProxyInfo Notebook_signal_switch_page_info =
 {
   "switch_page",
   (GCallback) &Notebook_signal_switch_page_callback,
   (GCallback) &Notebook_signal_switch_page_callback
 };
 
-
-static void Notebook_signal_page_reordered_callback(GtkNotebook* self, GtkWidget* p0,guint p1,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,Widget*,guint > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
-, p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo Notebook_signal_page_reordered_info =
-{
-  "page_reordered",
-  (GCallback) &Notebook_signal_page_reordered_callback,
-  (GCallback) &Notebook_signal_page_reordered_callback
-};
-
-
-static void Notebook_signal_page_removed_callback(GtkNotebook* self, GtkWidget* p0,guint p1,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,Widget*,guint > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
-, p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo Notebook_signal_page_removed_info =
-{
-  "page_removed",
-  (GCallback) &Notebook_signal_page_removed_callback,
-  (GCallback) &Notebook_signal_page_removed_callback
-};
-
-
-static void Notebook_signal_page_added_callback(GtkNotebook* self, GtkWidget* p0,guint p1,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,Widget*,guint > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
-, p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo Notebook_signal_page_added_info =
-{
-  "page_added",
-  (GCallback) &Notebook_signal_page_added_callback,
-  (GCallback) &Notebook_signal_page_added_callback
-};
-
-
 } // anonymous namespace
 
 // static
@@ -667,18 +516,10 @@ void Notebook_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->switch_page = &switch_page_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Notebook_Class::switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0, guint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -691,19 +532,15 @@ void Notebook_Class::switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_switch_page(p0, p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -716,7 +553,6 @@ void Notebook_Class::switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0
       (*base->switch_page)(self, p0, p1);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Notebook_Class::wrap_new(GObject* o)
@@ -797,17 +633,7 @@ int Notebook::insert_page(Widget& child, Widget& tab_label, Widget& menu_label,
 
 void Notebook::remove_page(int page_num)
 {
-gtk_notebook_remove_page(gobj(), page_num); 
-}
-
-void Notebook::set_group_id(int group_id)
-{
-gtk_notebook_set_group_id(gobj(), group_id); 
-}
-
-int Notebook::get_group_id() const
-{
-  return gtk_notebook_get_group_id(const_cast<GtkNotebook*>(gobj()));
+  gtk_notebook_remove_page(gobj(), page_num);
 }
 
 int Notebook::get_current_page() const
@@ -822,7 +648,7 @@ Widget* Notebook::get_nth_page(int page_num)
 
 const Widget* Notebook::get_nth_page(int page_num) const
 {
-  return const_cast<Notebook*>(this)->get_nth_page(page_num);
+  return Glib::wrap(gtk_notebook_get_nth_page(const_cast<GtkNotebook*>(gobj()), page_num));
 }
 
 int Notebook::get_n_pages()
@@ -837,22 +663,22 @@ int Notebook::page_num(const Widget& child)
 
 void Notebook::set_current_page(int page_num)
 {
-gtk_notebook_set_current_page(gobj(), page_num); 
+  gtk_notebook_set_current_page(gobj(), page_num);
 }
 
 void Notebook::next_page()
 {
-gtk_notebook_next_page(gobj()); 
+  gtk_notebook_next_page(gobj());
 }
 
 void Notebook::prev_page()
 {
-gtk_notebook_prev_page(gobj()); 
+  gtk_notebook_prev_page(gobj());
 }
 
 void Notebook::set_show_border(bool show_border)
 {
-gtk_notebook_set_show_border(gobj(), static_cast<int>(show_border)); 
+  gtk_notebook_set_show_border(gobj(), static_cast<int>(show_border));
 }
 
 bool Notebook::get_show_border() const
@@ -862,7 +688,7 @@ bool Notebook::get_show_border() const
 
 void Notebook::set_show_tabs(bool show_tabs)
 {
-gtk_notebook_set_show_tabs(gobj(), static_cast<int>(show_tabs)); 
+  gtk_notebook_set_show_tabs(gobj(), static_cast<int>(show_tabs));
 }
 
 bool Notebook::get_show_tabs() const
@@ -872,7 +698,7 @@ bool Notebook::get_show_tabs() const
 
 void Notebook::set_tab_pos(PositionType pos)
 {
-gtk_notebook_set_tab_pos(gobj(), ((GtkPositionType)(pos))); 
+  gtk_notebook_set_tab_pos(gobj(), ((GtkPositionType)(pos)));
 }
 
 PositionType Notebook::get_tab_pos() const
@@ -882,7 +708,7 @@ PositionType Notebook::get_tab_pos() const
 
 void Notebook::set_scrollable(bool scrollable)
 {
-gtk_notebook_set_scrollable(gobj(), static_cast<int>(scrollable)); 
+  gtk_notebook_set_scrollable(gobj(), static_cast<int>(scrollable));
 }
 
 bool Notebook::get_scrollable() const
@@ -892,12 +718,12 @@ bool Notebook::get_scrollable() const
 
 void Notebook::popup_enable()
 {
-gtk_notebook_popup_enable(gobj()); 
+  gtk_notebook_popup_enable(gobj());
 }
 
 void Notebook::popup_disable()
 {
-gtk_notebook_popup_disable(gobj()); 
+  gtk_notebook_popup_disable(gobj());
 }
 
 Widget* Notebook::get_tab_label(Widget& child)
@@ -907,17 +733,17 @@ Widget* Notebook::get_tab_label(Widget& child)
 
 const Widget* Notebook::get_tab_label(Widget& child) const
 {
-  return const_cast<Notebook*>(this)->get_tab_label(child);
+  return Glib::wrap(gtk_notebook_get_tab_label(const_cast<GtkNotebook*>(gobj()), (child).gobj()));
 }
 
 void Notebook::set_tab_label(Widget& child, Widget& tab_label)
 {
-gtk_notebook_set_tab_label(gobj(), (child).gobj(), (tab_label).gobj()); 
+  gtk_notebook_set_tab_label(gobj(), (child).gobj(), (tab_label).gobj());
 }
 
 void Notebook::set_tab_label_text(Widget& child, const Glib::ustring& tab_text)
 {
-gtk_notebook_set_tab_label_text(gobj(), (child).gobj(), tab_text.c_str()); 
+  gtk_notebook_set_tab_label_text(gobj(), (child).gobj(), tab_text.c_str());
 }
 
 Glib::ustring Notebook::get_tab_label_text(Widget& child) const
@@ -932,17 +758,17 @@ Widget* Notebook::get_menu_label(Widget& child)
 
 const Widget* Notebook::get_menu_label(Widget& child) const
 {
-  return const_cast<Notebook*>(this)->get_menu_label(child);
+  return Glib::wrap(gtk_notebook_get_menu_label(const_cast<GtkNotebook*>(gobj()), (child).gobj()));
 }
 
 void Notebook::set_menu_label(Widget& child, Widget& menu_label)
 {
-gtk_notebook_set_menu_label(gobj(), (child).gobj(), (menu_label).gobj()); 
+  gtk_notebook_set_menu_label(gobj(), (child).gobj(), (menu_label).gobj());
 }
 
 void Notebook::set_menu_label_text(Widget& child, const Glib::ustring& menu_text)
 {
-gtk_notebook_set_menu_label_text(gobj(), (child).gobj(), menu_text.c_str()); 
+  gtk_notebook_set_menu_label_text(gobj(), (child).gobj(), menu_text.c_str());
 }
 
 Glib::ustring Notebook::get_menu_label_text(Widget& child) const
@@ -952,32 +778,12 @@ Glib::ustring Notebook::get_menu_label_text(Widget& child) const
 
 void Notebook::set_tab_label_packing(Widget& child, bool expand, bool fill, PackType pack_type)
 {
-gtk_notebook_set_tab_label_packing(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), ((GtkPackType)(pack_type))); 
+  gtk_notebook_set_tab_label_packing(gobj(), (child).gobj(), static_cast<int>(expand), static_cast<int>(fill), ((GtkPackType)(pack_type)));
 }
 
 void Notebook::reorder_child(Widget& child, int position)
 {
-gtk_notebook_reorder_child(gobj(), (child).gobj(), position); 
-}
-
-bool Notebook::get_tab_reorderable(Widget& child) const
-{
-  return gtk_notebook_get_tab_reorderable(const_cast<GtkNotebook*>(gobj()), (child).gobj());
-}
-
-void Notebook::set_tab_reorderable(Widget& child, bool reorderable)
-{
-gtk_notebook_set_tab_reorderable(gobj(), (child).gobj(), static_cast<int>(reorderable)); 
-}
-
-bool Notebook::get_tab_detachable(Widget& child) const
-{
-  return gtk_notebook_get_tab_detachable(const_cast<GtkNotebook*>(gobj()), (child).gobj());
-}
-
-void Notebook::set_tab_detachable(Widget& child, bool detachable)
-{
-gtk_notebook_set_tab_detachable(gobj(), (child).gobj(), static_cast<int>(detachable)); 
+  gtk_notebook_reorder_child(gobj(), (child).gobj(), position);
 }
 
 
@@ -987,159 +793,107 @@ Glib::SignalProxy2< void,GtkNotebookPage*,guint > Notebook::signal_switch_page()
 }
 
 
-Glib::SignalProxy2< void,Widget*,guint > Notebook::signal_page_reordered()
-{
-  return Glib::SignalProxy2< void,Widget*,guint >(this, &Notebook_signal_page_reordered_info);
-}
-
-
-Glib::SignalProxy2< void,Widget*,guint > Notebook::signal_page_removed()
-{
-  return Glib::SignalProxy2< void,Widget*,guint >(this, &Notebook_signal_page_removed_info);
-}
-
-
-Glib::SignalProxy2< void,Widget*,guint > Notebook::signal_page_added()
-{
-  return Glib::SignalProxy2< void,Widget*,guint >(this, &Notebook_signal_page_added_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<PositionType> Notebook::property_tab_pos() 
 {
   return Glib::PropertyProxy<PositionType>(this, "tab-pos");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<PositionType> Notebook::property_tab_pos() const
 {
   return Glib::PropertyProxy_ReadOnly<PositionType>(this, "tab-pos");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Notebook::property_show_tabs() 
 {
   return Glib::PropertyProxy<bool>(this, "show-tabs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Notebook::property_show_tabs() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "show-tabs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Notebook::property_show_border() 
 {
   return Glib::PropertyProxy<bool>(this, "show-border");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Notebook::property_show_border() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "show-border");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Notebook::property_scrollable() 
 {
   return Glib::PropertyProxy<bool>(this, "scrollable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Notebook::property_scrollable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "scrollable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<guint> Notebook::property_tab_border() 
 {
   return Glib::PropertyProxy_WriteOnly<guint>(this, "tab-border");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<guint> Notebook::property_tab_border() const
+{
+  return Glib::PropertyProxy_ReadOnly<guint>(this, "tab-border");
+}
+
 Glib::PropertyProxy<guint> Notebook::property_tab_hborder() 
 {
   return Glib::PropertyProxy<guint>(this, "tab-hborder");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Notebook::property_tab_hborder() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "tab-hborder");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Notebook::property_tab_vborder() 
 {
   return Glib::PropertyProxy<guint>(this, "tab-vborder");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Notebook::property_tab_vborder() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "tab-vborder");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Notebook::property_page() 
 {
   return Glib::PropertyProxy<int>(this, "page");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Notebook::property_page() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "page");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Notebook::property_enable_popup() 
 {
   return Glib::PropertyProxy<bool>(this, "enable-popup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Notebook::property_enable_popup() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-popup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Notebook::property_homogeneous() 
 {
   return Glib::PropertyProxy<bool>(this, "homogeneous");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Notebook::property_homogeneous() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "homogeneous");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Notebook::on_switch_page(GtkNotebookPage* page, guint page_num)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1149,10 +903,6 @@ void Gtk::Notebook::on_switch_page(GtkNotebookPage* page, guint page_num)
   if(base && base->switch_page)
     (*base->switch_page)(gobj(),page,page_num);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/notebook.h b/libs/gtkmm2/gtk/gtkmm/notebook.h
index cb90d44ffc..47378df9ed 100644
--- a/libs/gtkmm2/gtk/gtkmm/notebook.h
+++ b/libs/gtkmm2/gtk/gtkmm/notebook.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_NOTEBOOK_H
 #define _GTKMM_NOTEBOOK_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -369,18 +368,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_switch_page(GtkNotebookPage* page, guint page_num);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -471,18 +464,6 @@ public:
   void remove_page(int page_num = 0);
   void remove_page(Widget& child);
 
-  /** For instance,
-   * Notebook* on_window_creation(Widget* page, int x, int y);
-   */
-  typedef sigc::slot<Notebook*, Widget*, int, int> SlotWindowCreation;
-
-  static void set_window_creation_hook(const SlotWindowCreation& slot);
-  
-
-  void set_group_id(int group_id);
-  
-  int get_group_id() const;
-
   
   /** Returns the page number of the current page.
    * @return The index (starting from 0) of the current
@@ -510,7 +491,7 @@ public:
   /** Gets the number of pages in a notebook.
    * @return The number of pages in the notebook.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int get_n_pages();
   /*Widget* get_current_page();*/ /*inconsistency with set_current_page*/
@@ -700,15 +681,6 @@ public:
    */
   void reorder_child(Widget& child, int position);
 
-  
-  bool get_tab_reorderable(Widget& child) const;
-  
-  void set_tab_reorderable(Widget& child, bool reorderable = true);
-  
-  bool get_tab_detachable(Widget& child) const;
-  
-  void set_tab_detachable(Widget& child, bool detachable = true);
-
 
   PageList::iterator get_current();
 
@@ -716,52 +688,20 @@ public:
   const PageList& pages() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %switch_page(GtkNotebookPage* page, guint page_num)</tt>
-   */
-
   Glib::SignalProxy2< void,GtkNotebookPage*,guint > signal_switch_page();
 
-  
-/**
-   * @par Prototype:
-   * <tt>void %page_reordered(Widget* page, guint page_num)</tt>
-   */
-
-  Glib::SignalProxy2< void,Widget*,guint > signal_page_reordered();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %page_removed(Widget* page, guint page_num)</tt>
-   */
-
-  Glib::SignalProxy2< void,Widget*,guint > signal_page_removed();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %page_added(Widget* page, guint page_num)</tt>
-   */
-
-  Glib::SignalProxy2< void,Widget*,guint > signal_page_added();
-
 
   //Key-binding signals:
   
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Which side of the notebook holds the tabs.
+  /** Which side of the notebook holds the tabs.
    *
    * 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<PositionType> property_tab_pos() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Which side of the notebook holds the tabs.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -769,19 +709,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<PositionType> property_tab_pos() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether tabs should be shown or not.
+  /** Whether tabs should be shown 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_show_tabs() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether tabs should be shown or not.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -789,19 +725,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_show_tabs() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the border should be shown or not.
+  /** Whether the border should be shown 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_show_border() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the border should be shown or not.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -809,19 +741,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_show_border() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
+  /** If TRUE
    *
    * 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_scrollable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -829,30 +757,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_scrollable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the border around the tab labels.
+  /** Width of the border around the tab labels.
    *
    * 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<guint> property_tab_border() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
+/** Width of the border around the tab labels.
+   *
+   * 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_tab_border() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the horizontal border of tab labels.
+  /** Width of the horizontal border of tab labels.
    *
    * 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_tab_hborder() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Width of the horizontal border of tab labels.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -860,19 +789,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_tab_hborder() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the vertical border of tab labels.
+  /** Width of the vertical border of tab labels.
    *
    * 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_tab_vborder() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Width of the vertical border of tab labels.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -880,19 +805,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_tab_vborder() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The index of the current page.
+  /** The index of the current page.
    *
    * 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_page() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The index of the current page.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -900,19 +821,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_page() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
+  /** If TRUE
    *
    * 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_enable_popup() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -920,19 +837,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_enable_popup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether tabs should have homogeneous sizes.
+  /** Whether tabs should have homogeneous sizes.
    *
    * 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_homogeneous() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether tabs should have homogeneous sizes.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -940,7 +853,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_homogeneous() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -986,8 +898,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Notebook* wrap(GtkNotebook* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_NOTEBOOK_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/object.cc b/libs/gtkmm2/gtk/gtkmm/object.cc
index cddd6759c2..b61a028949 100644
--- a/libs/gtkmm2/gtk/gtkmm/object.cc
+++ b/libs/gtkmm2/gtk/gtkmm/object.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/object.h>
 #include <gtkmm/private/object_p.h>
 
@@ -60,10 +59,11 @@ void Object::_init_unmanage(bool /* is_toplevel = false */)
 
     // Most GTK+ objects are floating, by default. This means that the container widget controls their lifetime.
     // We'll change this:
-    if(g_object_is_floating (gobject_)) //Top-level Windows and Dialogs can not be manag()ed, so there is no need to do this.
+    if(GTK_OBJECT_FLOATING (gobject_)) //Top-level Windows and Dialogs can not be manag()ed, so there is no need to do this.
     {
       GLIBMM_DEBUG_REFERENCE(this, gobject_);
-      g_object_ref_sink(gobject_); //Stops it from being floating - we will make this optional ( see Gtk::manage() ),
+      g_object_ref(gobject_);  //Increase ref by 1 so that it doesn't get deleted when we sink() it (sink()ing does an unref)
+      gtk_object_sink((GtkObject*)gobject_); //Stops it from being floating - we will make this optional ( see Gtk::manage() ),
 
       #ifdef GLIBMM_DEBUG_REFCOUNTING
       g_warning("gtkmm after sink: C++ instance: %p, C instance: %p, refcount=%d\n", (void*)(Glib::ObjectBase*)this, (void*)gobject_, G_OBJECT(gobject_)->ref_count);
@@ -75,7 +75,7 @@ void Object::_init_unmanage(bool /* is_toplevel = false */)
     else
     {
        //This widget is already not floating. It's probably already been added to a GTK+ container, and has just had Glib::wrap() called on it.
-       //It's not floating because containers call g_object_sink() on child widgets to take control of them.
+       //It's not floating because containers call gtk_object_sink() on child widgets to take control of them.
        //We just ref() it so that we can unref it later.
        //GLIBMM_DEBUG_REFERENCE(this, gobject_);
        //g_object_ref(gobject_);
@@ -285,8 +285,7 @@ void Object::set_manage()
       g_warning("Object::set_manage(): setting GTK_FLOATING: gobject_ = %p", (void*) gobj());
       g_warning("  gtypename=%s\n", G_OBJECT_TYPE_NAME(gobj()));
     #endif
-    //deprecated: GTK_OBJECT_SET_FLAGS(gobj(), GTK_FLOATING);
-    g_object_force_floating(gobject_);
+    GTK_OBJECT_SET_FLAGS(gobj(), GTK_FLOATING);
   }
   else
   {
@@ -367,19 +366,8 @@ void Object_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Object_Class::wrap_new(GObject* o)
 {
@@ -403,26 +391,15 @@ GType Object::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<void*> Object::property_user_data() 
 {
   return Glib::PropertyProxy<void*>(this, "user-data");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<void*> Object::property_user_data() const
 {
   return Glib::PropertyProxy_ReadOnly<void*>(this, "user-data");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/object.h b/libs/gtkmm2/gtk/gtkmm/object.h
index 2f7f07c263..3ca724d358 100644
--- a/libs/gtkmm2/gtk/gtkmm/object.h
+++ b/libs/gtkmm2/gtk/gtkmm/object.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_OBJECT_H
 #define _GTKMM_OBJECT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -43,16 +42,6 @@ namespace Gtk
 
 class Object;
 
-/** Mark a Gtk::Object as owned by its parent container widget, so you don't need to delete it manually.
- * For instance,
- * @code
- * Gtk::Button* button = Gtk::manage( new Gtk::Button("Hello") );
- * vbox.pack_start(*button); //vbox will delete button when vbox is deleted.
- * @endcode
- *
- * @param obj A Gtk::Object, such as a gtkmm widget.
- * @result The Gtk::Object passed as the @a obj parameter.
- */
 template<class T>
 T* manage(T* obj)
 {
@@ -60,16 +49,8 @@ T* manage(T* obj)
   return obj;
 }
 
-/** Gtk::Object is the base class for all widgets, and for a few non-widget objects such as 
- * Gtk::Adjustment. Gtk::Object predates Glib::Object; non-widgets that derive from Gtk::Object 
- * rather than Glib::Object do so for backward compatibility reasons.
- *
- * The most interesting difference between Gtk::Object and Glib::Object is the ability to use Gtk::manage() to delegate memory management to the container widget. Gtk::Objects can also be 
- * explicitly deleted at any time, instead of using only reference-counting, and container widgets 
- * can respond when their child objects are being deleted (for instance by removing the widget).
- */
 
-class GTKMM_API Object : public Glib::Object
+class Object : public Glib::Object
 {
   public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -112,17 +93,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -135,23 +110,16 @@ public:
   //void set_user_data(gpointer data);
   //gpointer get_user_data();
 
-  #ifndef DOXYGEN_SHOULD_SKIP_THIS
-  /** Used by Gtk::manage(). You should not need to use this directly.
-   */
   virtual void set_manage();
-  #endif //DOXYGEN_SHOULD_SKIP_THIS
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Anonymous User Data Pointer.
+  /** Anonymous User Data Pointer.
    *
    * 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<void*> property_user_data() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Anonymous User Data Pointer.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -159,28 +127,18 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<void*> property_user_data() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifndef DOXYGEN_SHOULD_SKIP_THIS
-  /** Private API.
-   */
   bool is_managed_() const;
-  #endif //DOXYGEN_SHOULD_SKIP_THIS
 
 protected:
 
-  #ifndef DOXYGEN_SHOULD_SKIP_THIS
-  /** Private API.
-   */
   void destroy_();
-  #endif //DOXYGEN_SHOULD_SKIP_THIS
 
   // If you need it, give me an example. murrayc. -- Me too. daniel.
   //_WRAP_SIGNAL(void destroy(), "destroy")
   
 
-  #ifndef DOXYGEN_SHOULD_SKIP_THIS
   void _init_unmanage(bool is_toplevel = false);
   virtual void destroy_notify_(); //override.
   void disconnect_cpp_wrapper();
@@ -190,7 +148,6 @@ protected:
   // set if flags used by derived classes.
   bool referenced_; // = not managed.
   bool gobject_disposed_;
-  #endif //DOXYGEN_SHOULD_SKIP_THIS
 
 
 };
@@ -206,8 +163,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Object* wrap(GtkObject* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_OBJECT_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/optionmenu.cc b/libs/gtkmm2/gtk/gtkmm/optionmenu.cc
index bf845e5833..6985768688 100644
--- a/libs/gtkmm2/gtk/gtkmm/optionmenu.cc
+++ b/libs/gtkmm2/gtk/gtkmm/optionmenu.cc
@@ -1,8 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <gtkmm/optionmenu.h>
 #include <gtkmm/private/optionmenu_p.h>
 
@@ -78,15 +75,13 @@ void OptionMenu::init_accels_handler_()
 namespace
 {
 
-
-static const Glib::SignalProxyInfo OptionMenu_signal_changed_info =
+const Glib::SignalProxyInfo OptionMenu_signal_changed_info =
 {
   "changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -131,18 +126,10 @@ void OptionMenu_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->changed = &changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void OptionMenu_Class::changed_callback(GtkOptionMenu* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -155,19 +142,15 @@ void OptionMenu_Class::changed_callback(GtkOptionMenu* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -180,7 +163,6 @@ void OptionMenu_Class::changed_callback(GtkOptionMenu* self)
       (*base->changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* OptionMenu_Class::wrap_new(GObject* o)
@@ -219,7 +201,7 @@ GType OptionMenu::get_base_type()
 
 void OptionMenu::set_menu(Menu& menu)
 {
-gtk_option_menu_set_menu(gobj(), (menu).Gtk::Widget::gobj()); 
+  gtk_option_menu_set_menu(gobj(), (menu).Gtk::Widget::gobj());
 }
 
 Menu* OptionMenu::get_menu()
@@ -229,12 +211,12 @@ Menu* OptionMenu::get_menu()
 
 const Menu* OptionMenu::get_menu() const
 {
-  return const_cast<OptionMenu*>(this)->get_menu();
+  return Glib::wrap((GtkMenu*)(gtk_option_menu_get_menu(const_cast<GtkOptionMenu*>(gobj()))));
 }
 
 void OptionMenu::remove_menu()
 {
-gtk_option_menu_remove_menu(gobj()); 
+  gtk_option_menu_remove_menu(gobj());
 }
 
 int OptionMenu::get_history() const
@@ -244,7 +226,7 @@ int OptionMenu::get_history() const
 
 void OptionMenu::set_history(guint index)
 {
-gtk_option_menu_set_history(gobj(), index); 
+  gtk_option_menu_set_history(gobj(), index);
 }
 
 
@@ -254,7 +236,6 @@ Glib::SignalProxy0< void > OptionMenu::signal_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::OptionMenu::on_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -264,14 +245,8 @@ void Gtk::OptionMenu::on_changed()
   if(base && base->changed)
     (*base->changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
diff --git a/libs/gtkmm2/gtk/gtkmm/optionmenu.h b/libs/gtkmm2/gtk/gtkmm/optionmenu.h
index bd88612a02..6f9633a256 100644
--- a/libs/gtkmm2/gtk/gtkmm/optionmenu.h
+++ b/libs/gtkmm2/gtk/gtkmm/optionmenu.h
@@ -3,9 +3,6 @@
 #ifndef _GTKMM_OPTIONMENU_H
 #define _GTKMM_OPTIONMENU_H
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -98,23 +95,16 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
 
-  
 public:
 
   OptionMenu();
@@ -138,11 +128,6 @@ public:
   void set_history(guint index);
 
   
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_changed();
 	
 
@@ -163,11 +148,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::OptionMenu* wrap(GtkOptionMenu* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
+}
 #endif /* _GTKMM_OPTIONMENU_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/pagesetup.cc b/libs/gtkmm2/gtk/gtkmm/pagesetup.cc
deleted file mode 100644
index 1fd7f16493..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/pagesetup.cc
+++ /dev/null
@@ -1,241 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/pagesetup.h>
-#include <gtkmm/private/pagesetup_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkpagesetup.h>
-#include <gtk/gtktypebuiltins.h>
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::PageSetup> wrap(GtkPageSetup* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::PageSetup>( dynamic_cast<Gtk::PageSetup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& PageSetup_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_ = &PageSetup_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(gtk_page_setup_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void PageSetup_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PageSetup_Class::wrap_new(GObject* object)
-{
-  return new PageSetup((GtkPageSetup*)object);
-}
-
-
-/* The implementation: */
-
-GtkPageSetup* PageSetup::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-PageSetup::PageSetup(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-PageSetup::PageSetup(GtkPageSetup* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-PageSetup::~PageSetup()
-{}
-
-
-PageSetup::CppClassType PageSetup::pagesetup_class_; // initialize static member
-
-GType PageSetup::get_type()
-{
-  return pagesetup_class_.init().get_type();
-}
-
-GType PageSetup::get_base_type()
-{
-  return gtk_page_setup_get_type();
-}
-
-
-PageSetup::PageSetup()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(pagesetup_class_.init()))
-{
-  }
-
-Glib::RefPtr<PageSetup> PageSetup::create()
-{
-  return Glib::RefPtr<PageSetup>( new PageSetup() );
-}
-PageOrientation PageSetup::get_orientation() const
-{
-  return (PageOrientation)gtk_page_setup_get_orientation(const_cast<GtkPageSetup*>(gobj()));
-}
-
-void PageSetup::set_orientation(PageOrientation orientation)
-{
-gtk_page_setup_set_orientation(gobj(), ((GtkPageOrientation)(orientation))); 
-}
-
-PaperSize PageSetup::get_paper_size()
-{
-  return Glib::wrap(gtk_page_setup_get_paper_size(gobj()), true);
-}
-
-const PaperSize PageSetup::get_paper_size() const
-{
-  return const_cast<PageSetup*>(this)->get_paper_size();
-}
-
-void PageSetup::set_paper_size(const PaperSize& paper_size)
-{
-gtk_page_setup_set_paper_size(gobj(), const_cast<GtkPaperSize*>((paper_size).gobj())); 
-}
-
-double PageSetup::get_top_margin(Unit unit) const
-{
-  return gtk_page_setup_get_top_margin(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-void PageSetup::set_top_margin(double margin, Unit unit)
-{
-gtk_page_setup_set_top_margin(gobj(), margin, ((GtkUnit)(unit))); 
-}
-
-double PageSetup::get_bottom_margin(Unit unit) const
-{
-  return gtk_page_setup_get_bottom_margin(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-void PageSetup::set_bottom_margin(double margin, Unit unit)
-{
-gtk_page_setup_set_bottom_margin(gobj(), margin, ((GtkUnit)(unit))); 
-}
-
-double PageSetup::get_left_margin(Unit unit) const
-{
-  return gtk_page_setup_get_left_margin(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-void PageSetup::set_left_margin(double margin, Unit unit)
-{
-gtk_page_setup_set_left_margin(gobj(), margin, ((GtkUnit)(unit))); 
-}
-
-double PageSetup::get_right_margin(Unit unit) const
-{
-  return gtk_page_setup_get_right_margin(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-void PageSetup::set_right_margin(double margin, Unit unit)
-{
-gtk_page_setup_set_right_margin(gobj(), margin, ((GtkUnit)(unit))); 
-}
-
-void PageSetup::set_paper_size_and_default_margins(const PaperSize& paper_size)
-{
-gtk_page_setup_set_paper_size_and_default_margins(gobj(), const_cast<GtkPaperSize*>((paper_size).gobj())); 
-}
-
-double PageSetup::get_paper_width(Unit unit) const
-{
-  return gtk_page_setup_get_paper_width(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-double PageSetup::get_paper_height(Unit unit) const
-{
-  return gtk_page_setup_get_paper_height(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-double PageSetup::get_page_width(Unit unit) const
-{
-  return gtk_page_setup_get_page_width(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-double PageSetup::get_page_height(Unit unit) const
-{
-  return gtk_page_setup_get_page_height(const_cast<GtkPageSetup*>(gobj()), ((GtkUnit)(unit)));
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/pagesetup.h b/libs/gtkmm2/gtk/gtkmm/pagesetup.h
deleted file mode 100644
index 5ff810ca76..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/pagesetup.h
+++ /dev/null
@@ -1,189 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PAGESETUP_H
-#define _GTKMM_PAGESETUP_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/object.h>
-#include <gtkmm/enums.h>
-#include <gtkmm/papersize.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPageSetup GtkPageSetup;
-typedef struct _GtkPageSetupClass GtkPageSetupClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PageSetup_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** A PageSetup object stores the page size, orientation and margins. You can get one of these from the page setup dialog 
- * and then pass it to the PrintOperation when printing. The benefit of splitting this out of the PrintSettings is that 
- * these affect the actual layout of the page, and thus need to be set long before the user prints.
- *
- * The margins specified in this object are the "print margins", i.e. the parts of the page that the printer cannot print  
- * on. These are different from the layout margins that a word processor uses; they are typically used to determine the 
- * minimal size for the layout margins.
- *
- * To obtain a PageSetup use PageSetup::create() to get the defaults, or use run_page_setup_dialog() to show the page 
- * setup dialog and receive the resulting page setup. 
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PageSetup : public Glib::Object
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef PageSetup CppObjectType;
-  typedef PageSetup_Class CppClassType;
-  typedef GtkPageSetup BaseObjectType;
-  typedef GtkPageSetupClass BaseClassType;
-
-private:  friend class PageSetup_Class;
-  static CppClassType pagesetup_class_;
-
-private:
-  // noncopyable
-  PageSetup(const PageSetup&);
-  PageSetup& operator=(const PageSetup&);
-
-protected:
-  explicit PageSetup(const Glib::ConstructParams& construct_params);
-  explicit PageSetup(GtkPageSetup* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~PageSetup();
-
-#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 GObject.
-  GtkPageSetup*       gobj()       { return reinterpret_cast<GtkPageSetup*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkPageSetup* gobj() const { return reinterpret_cast<GtkPageSetup*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkPageSetup* gobj_copy();
-
-private:
-
-protected:
-  PageSetup();
-
-public:
-  
-  static Glib::RefPtr<PageSetup> create();
-
-
-  PageOrientation get_orientation() const;
-  
-  void set_orientation(PageOrientation orientation);
-
-  
-  PaperSize get_paper_size();
-  
-  const PaperSize get_paper_size() const;
-  
-  void set_paper_size(const PaperSize& paper_size);
-
-  
-  double get_top_margin(Unit unit) const;
-  
-  void set_top_margin(double margin, Unit unit);
-
-  
-  double get_bottom_margin(Unit unit) const;
-  
-  void set_bottom_margin(double margin, Unit unit);
-
-  
-  double get_left_margin(Unit unit) const;
-  
-  void set_left_margin(double margin, Unit unit);
-
-  
-  double get_right_margin(Unit unit) const;
-  
-  void set_right_margin(double margin, Unit unit);
-
-  
-  void set_paper_size_and_default_margins(const PaperSize& paper_size);
-
-  
-  double get_paper_width(Unit unit) const;
-  
-  double get_paper_height(Unit unit) const;
-
-  
-  double get_page_width(Unit unit) const;
-  
-  double get_page_height(Unit unit) const;
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PageSetup
-   * @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<Gtk::PageSetup> wrap(GtkPageSetup* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_PAGESETUP_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/pagesetupunixdialog.cc b/libs/gtkmm2/gtk/gtkmm/pagesetupunixdialog.cc
deleted file mode 100644
index 0c37d00aab..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/pagesetupunixdialog.cc
+++ /dev/null
@@ -1,196 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/pagesetupunixdialog.h>
-#include <gtkmm/private/pagesetupunixdialog_p.h>
-
-// -*- c++ -*-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkpagesetupunixdialog.h>
-
-namespace Gtk
-{
-
-PageSetupUnixDialog::PageSetupUnixDialog(Gtk::Window& parent, const Glib::ustring& title)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(pagesetupunixdialog_class_.init(), "title",title.c_str(), (char*) 0))
-{
-  set_transient_for(parent);
-}
-
-PageSetupUnixDialog::PageSetupUnixDialog(const Glib::ustring& title)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(pagesetupunixdialog_class_.init(), "title",title.c_str(), (char*) 0))
-{
-}
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::PageSetupUnixDialog* wrap(GtkPageSetupUnixDialog* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::PageSetupUnixDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& PageSetupUnixDialog_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_ = &PageSetupUnixDialog_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(gtk_page_setup_unix_dialog_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void PageSetupUnixDialog_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PageSetupUnixDialog_Class::wrap_new(GObject* o)
-{
-  return manage(new PageSetupUnixDialog((GtkPageSetupUnixDialog*)(o)));
-
-}
-
-
-/* The implementation: */
-
-PageSetupUnixDialog::PageSetupUnixDialog(const Glib::ConstructParams& construct_params)
-:
-  Gtk::Dialog(construct_params)
-{
-  }
-
-PageSetupUnixDialog::PageSetupUnixDialog(GtkPageSetupUnixDialog* castitem)
-:
-  Gtk::Dialog((GtkDialog*)(castitem))
-{
-  }
-
-PageSetupUnixDialog::~PageSetupUnixDialog()
-{
-  destroy_();
-}
-
-PageSetupUnixDialog::CppClassType PageSetupUnixDialog::pagesetupunixdialog_class_; // initialize static member
-
-GType PageSetupUnixDialog::get_type()
-{
-  return pagesetupunixdialog_class_.init().get_type();
-}
-
-GType PageSetupUnixDialog::get_base_type()
-{
-  return gtk_page_setup_unix_dialog_get_type();
-}
-
-
-void PageSetupUnixDialog::set_page_setup(const Glib::RefPtr<PageSetup>& page_setup)
-{
-gtk_page_setup_unix_dialog_set_page_setup(gobj(), Glib::unwrap(page_setup)); 
-}
-
-Glib::RefPtr<PageSetup> PageSetupUnixDialog::get_page_setup()
-{
-
-  Glib::RefPtr<PageSetup> retvalue = Glib::wrap(gtk_page_setup_unix_dialog_get_page_setup(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const PageSetup> PageSetupUnixDialog::get_page_setup() const
-{
-  return const_cast<PageSetupUnixDialog*>(this)->get_page_setup();
-}
-
-void PageSetupUnixDialog::set_print_settings(const Glib::RefPtr<PrintSettings>& print_settings)
-{
-gtk_page_setup_unix_dialog_set_print_settings(gobj(), Glib::unwrap(print_settings)); 
-}
-
-Glib::RefPtr<PrintSettings> PageSetupUnixDialog::get_print_settings()
-{
-
-  Glib::RefPtr<PrintSettings> retvalue = Glib::wrap(gtk_page_setup_unix_dialog_get_print_settings(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const PrintSettings> PageSetupUnixDialog::get_print_settings() const
-{
-  return const_cast<PageSetupUnixDialog*>(this)->get_print_settings();
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/pagesetupunixdialog.h b/libs/gtkmm2/gtk/gtkmm/pagesetupunixdialog.h
deleted file mode 100644
index 3177c56517..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/pagesetupunixdialog.h
+++ /dev/null
@@ -1,152 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PAGESETUPUNIXDIALOG_H
-#define _GTKMM_PAGESETUPUNIXDIALOG_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/dialog.h>
-#include <gtkmm/pagesetup.h>
-#include <gtkmm/printsettings.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPageSetupUnixDialog GtkPageSetupUnixDialog;
-typedef struct _GtkPageSetupUnixDialogClass GtkPageSetupUnixDialogClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PageSetupUnixDialog_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** PageSetupUnixDialog implements a page setup dialog for platforms
- * which don't provide a native page setup dialog, like Unix. It can
- * be used very much like any other GTK+ dialog, at the cost of
- * the portability offered by the high-level printing API exposed
- * through PrintOperation.
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PageSetupUnixDialog : public Dialog
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PageSetupUnixDialog CppObjectType;
-  typedef PageSetupUnixDialog_Class CppClassType;
-  typedef GtkPageSetupUnixDialog BaseObjectType;
-  typedef GtkPageSetupUnixDialogClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~PageSetupUnixDialog();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class PageSetupUnixDialog_Class;
-  static CppClassType pagesetupunixdialog_class_;
-
-  // noncopyable
-  PageSetupUnixDialog(const PageSetupUnixDialog&);
-  PageSetupUnixDialog& operator=(const PageSetupUnixDialog&);
-
-protected:
-  explicit PageSetupUnixDialog(const Glib::ConstructParams& construct_params);
-  explicit PageSetupUnixDialog(GtkPageSetupUnixDialog* 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.
-  GtkPageSetupUnixDialog*       gobj()       { return reinterpret_cast<GtkPageSetupUnixDialog*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkPageSetupUnixDialog* gobj() const { return reinterpret_cast<GtkPageSetupUnixDialog*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-  //This is not available in on Win32.
-//This source file will not be compiled,
-//and the class will not be registered in wrap_init.h or wrap_init.cc
-
-
-public:
-  explicit PageSetupUnixDialog(Gtk::Window& parent, const Glib::ustring& title);
-  explicit PageSetupUnixDialog(const Glib::ustring& title);
-
-  
-  void set_page_setup(const Glib::RefPtr<PageSetup>& page_setup);
-  
-  Glib::RefPtr<PageSetup> get_page_setup();
-  
-  Glib::RefPtr<const PageSetup> get_page_setup() const;
-
-  
-  void set_print_settings(const Glib::RefPtr<PrintSettings>& print_settings);
-  
-  Glib::RefPtr<PrintSettings> get_print_settings();
-  
-  Glib::RefPtr<const PrintSettings> get_print_settings() const;
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PageSetupUnixDialog
-   * @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.
-   */
-  Gtk::PageSetupUnixDialog* wrap(GtkPageSetupUnixDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_PAGESETUPUNIXDIALOG_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/paned.cc b/libs/gtkmm2/gtk/gtkmm/paned.cc
index 94a884ce16..4b160994bc 100644
--- a/libs/gtkmm2/gtk/gtkmm/paned.cc
+++ b/libs/gtkmm2/gtk/gtkmm/paned.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/paned.h>
 #include <gtkmm/private/paned_p.h>
 
@@ -98,19 +97,8 @@ void Paned_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Paned_Class::wrap_new(GObject* o)
 {
@@ -160,22 +148,22 @@ Paned::Paned()
 
 void Paned::add1(Widget& child)
 {
-gtk_paned_add1(gobj(), (child).gobj()); 
+  gtk_paned_add1(gobj(), (child).gobj());
 }
 
 void Paned::add2(Widget& child)
 {
-gtk_paned_add2(gobj(), (child).gobj()); 
+  gtk_paned_add2(gobj(), (child).gobj());
 }
 
 void Paned::pack1(Widget& child, bool resize, bool shrink)
 {
-gtk_paned_pack1(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink)); 
+  gtk_paned_pack1(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink));
 }
 
 void Paned::pack2(Widget& child, bool resize, bool shrink)
 {
-gtk_paned_pack2(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink)); 
+  gtk_paned_pack2(gobj(), (child).gobj(), static_cast<int>(resize), static_cast<int>(shrink));
 }
 
 int Paned::get_position() const
@@ -185,7 +173,7 @@ int Paned::get_position() const
 
 void Paned::set_position(int position)
 {
-gtk_paned_set_position(gobj(), position); 
+  gtk_paned_set_position(gobj(), position);
 }
 
 Widget* Paned::get_child1()
@@ -195,7 +183,7 @@ Widget* Paned::get_child1()
 
 const Widget* Paned::get_child1() const
 {
-  return const_cast<Paned*>(this)->get_child1();
+  return Glib::wrap(gtk_paned_get_child1(const_cast<GtkPaned*>(gobj())));
 }
 
 Widget* Paned::get_child2()
@@ -205,58 +193,39 @@ Widget* Paned::get_child2()
 
 const Widget* Paned::get_child2() const
 {
-  return const_cast<Paned*>(this)->get_child2();
+  return Glib::wrap(gtk_paned_get_child2(const_cast<GtkPaned*>(gobj())));
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Paned::property_position() 
 {
   return Glib::PropertyProxy<int>(this, "position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Paned::property_position() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Paned::property_position_set() 
 {
   return Glib::PropertyProxy<bool>(this, "position-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Paned::property_position_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "position-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Paned::property_min_position() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "min-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Paned::property_max_position() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "max-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -303,19 +272,8 @@ void HPaned_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* HPaned_Class::wrap_new(GObject* o)
 {
@@ -363,13 +321,6 @@ HPaned::HPaned()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -414,19 +365,8 @@ void VPaned_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* VPaned_Class::wrap_new(GObject* o)
 {
@@ -474,13 +414,6 @@ VPaned::VPaned()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/paned.h b/libs/gtkmm2/gtk/gtkmm/paned.h
index 45298ae9b5..5616d261c5 100644
--- a/libs/gtkmm2/gtk/gtkmm/paned.h
+++ b/libs/gtkmm2/gtk/gtkmm/paned.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_PANED_H
 #define _GTKMM_PANED_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -129,17 +128,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -177,14 +170,14 @@ public:
   /** Obtains the first child of the paned widget.
    * @return First child, or <tt>0</tt> if it is not set.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* get_child1();
   
   /** Obtains the first child of the paned widget.
    * @return First child, or <tt>0</tt> if it is not set.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* get_child1() const;
 
@@ -192,31 +185,28 @@ public:
   /** Obtains the second child of the paned widget.
    * @return Second child, or <tt>0</tt> if it is not set.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* get_child2();
   
   /** Obtains the second child of the paned widget.
    * @return Second child, or <tt>0</tt> if it is not set.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* get_child2() const;
  
   //Keybinding signals:
   
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Position of paned separator in pixels (0 means all the way to the left/top).
+  /** Position of paned separator in pixels (0 means all the way to the left/top).
    *
    * 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_position() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Position of paned separator in pixels (0 means all the way to the left/top).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -224,19 +214,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if the Position property should be used.
+  /** TRUE if the Position property should be used.
    *
    * 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_position_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** TRUE if the Position property should be used.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -244,28 +230,23 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_position_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Smallest possible value for the position property.
+  /** Smallest possible value for the position property.
    *
    * 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_min_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Largest possible value for the position property.
+  /** Largest possible value for the position property.
    *
    * 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_max_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -321,17 +302,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -393,17 +368,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -425,9 +394,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Paned* wrap(GtkPaned* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::HPaned
@@ -436,9 +403,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HPaned* wrap(GtkHPaned* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::VPaned
@@ -447,8 +412,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::VPaned* wrap(GtkVPaned* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_PANED_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/papersize.cc b/libs/gtkmm2/gtk/gtkmm/papersize.cc
deleted file mode 100644
index 68606cfdce..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/papersize.cc
+++ /dev/null
@@ -1,204 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/papersize.h>
-#include <gtkmm/private/papersize_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkpapersize.h>
-#include <gtk/gtktypebuiltins.h>
-
-namespace Gtk
-{
-
-//PaperSize::PaperSize()
-//:
-//  gobject_(gtk_paper_size_new(gtk_paper_size_get_default()))
-//{}
-
-PaperSize::PaperSize(const Glib::ustring& name)
-:
-  gobject_(gtk_paper_size_new(name.c_str()))
-{}
-
-PaperSize::PaperSize(const Glib::ustring& ppd_name, const Glib::ustring& ppd_display_name, double width, double height)
-:
-  gobject_(gtk_paper_size_new_from_ppd(ppd_name.c_str(),
-                                       ppd_display_name.c_str(),
-                                       gdouble(width),
-                                       gdouble(height)))
-{}
-
-PaperSize::PaperSize(const Glib::ustring& name, const Glib::ustring& display_name, double width, double height, Unit unit)
-:
-  gobject_(gtk_paper_size_new_custom(name.c_str(),
-                                     display_name.c_str(),
-                                     gdouble(width),
-                                     gdouble(height),
-                                     GtkUnit(unit)))
-{}
-
-bool PaperSize::equal(const PaperSize& other) const
-{
-  return (static_cast<bool>(gtk_paper_size_is_equal(const_cast<GtkPaperSize*>(this->gobj()),
-                                                    const_cast<GtkPaperSize*>(other.gobj()))));
-}
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-// static
-GType Glib::Value<Gtk::Unit>::value_type()
-{
-  return gtk_unit_get_type();
-}
-
-
-namespace Glib
-{
-
-Gtk::PaperSize wrap(GtkPaperSize* object, bool take_copy)
-{
-  return Gtk::PaperSize(object, take_copy);
-}
-
-} // namespace Glib
-
-
-namespace Gtk
-{
-
-
-// static
-GType PaperSize::get_type()
-{
-  return gtk_paper_size_get_type();
-}
-
-PaperSize::PaperSize()
-:
-  gobject_ (0) // Allows creation of invalid wrapper, e.g. for output arguments to methods.
-{}
-
-PaperSize::PaperSize(const PaperSize& other)
-:
-  gobject_ ((other.gobject_) ? gtk_paper_size_copy(other.gobject_) : 0)
-{}
-
-PaperSize::PaperSize(GtkPaperSize* gobject, bool make_a_copy)
-:
-  // For BoxedType wrappers, make_a_copy is true by default.  The static
-  // BoxedType wrappers must always take a copy, thus make_a_copy = true
-  // ensures identical behaviour if the default argument is used.
-  gobject_ ((make_a_copy && gobject) ? gtk_paper_size_copy(gobject) : gobject)
-{}
-
-PaperSize& PaperSize::operator=(const PaperSize& other)
-{
-  PaperSize temp (other);
-  swap(temp);
-  return *this;
-}
-
-PaperSize::~PaperSize()
-{
-  if(gobject_)
-    gtk_paper_size_free(gobject_);
-}
-
-void PaperSize::swap(PaperSize& other)
-{
-  GtkPaperSize *const temp = gobject_;
-  gobject_ = other.gobject_;
-  other.gobject_ = temp;
-}
-
-GtkPaperSize* PaperSize::gobj_copy() const
-{
-  return gtk_paper_size_copy(gobject_);
-}
-
-
-Glib::ustring PaperSize::get_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_paper_size_get_name(const_cast<GtkPaperSize*>(gobj())));
-}
-
-Glib::ustring PaperSize::get_display_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_paper_size_get_display_name(const_cast<GtkPaperSize*>(gobj())));
-}
-
-Glib::ustring PaperSize::get_ppd_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_paper_size_get_ppd_name(const_cast<GtkPaperSize*>(gobj())));
-}
-
-double PaperSize::get_width(Unit unit) const
-{
-  return gtk_paper_size_get_width(const_cast<GtkPaperSize*>(gobj()), ((GtkUnit)(unit)));
-}
-
-double PaperSize::get_height(Unit unit) const
-{
-  return gtk_paper_size_get_height(const_cast<GtkPaperSize*>(gobj()), ((GtkUnit)(unit)));
-}
-
-bool PaperSize::is_custom() const
-{
-  return gtk_paper_size_is_custom(const_cast<GtkPaperSize*>(gobj()));
-}
-
-void PaperSize::set_size(double width, double height, Unit unit)
-{
-gtk_paper_size_set_size(gobj(), width, height, ((GtkUnit)(unit))); 
-}
-
-double PaperSize::get_default_top_margin(Unit unit) const
-{
-  return gtk_paper_size_get_default_top_margin(const_cast<GtkPaperSize*>(gobj()), ((GtkUnit)(unit)));
-}
-
-double PaperSize::get_default_bottom_margin(Unit unit) const
-{
-  return gtk_paper_size_get_default_bottom_margin(const_cast<GtkPaperSize*>(gobj()), ((GtkUnit)(unit)));
-}
-
-double PaperSize::get_default_left_margin(Unit unit) const
-{
-  return gtk_paper_size_get_default_left_margin(const_cast<GtkPaperSize*>(gobj()), ((GtkUnit)(unit)));
-}
-
-double PaperSize::get_default_right_margin(Unit unit) const
-{
-  return gtk_paper_size_get_default_right_margin(const_cast<GtkPaperSize*>(gobj()), ((GtkUnit)(unit)));
-}
-
-Glib::ustring PaperSize::get_default()
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_paper_size_get_default());
-}
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/papersize.h b/libs/gtkmm2/gtk/gtkmm/papersize.h
deleted file mode 100644
index d1e38bf18f..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/papersize.h
+++ /dev/null
@@ -1,212 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PAPERSIZE_H
-#define _GTKMM_PAPERSIZE_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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.
- */
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-extern "C" { typedef struct _GtkPaperSize GtkPaperSize; }
-#endif
-
-namespace Gtk
-{
-
-/** Common paper names, from PWG 5101.1-2002 PWG: Standard for Media Standardized Names
- *
- */
-const Glib::ustring PAPER_NAME_A3 = "iso_a3";
-const Glib::ustring PAPER_NAME_A4 = "iso_a4";
-const Glib::ustring PAPER_NAME_A5 = "iso_a5";
-const Glib::ustring PAPER_NAME_B5 = "iso_b5";
-const Glib::ustring PAPER_NAME_LETTER = "na_letter";
-const Glib::ustring PAPER_NAME_EXECUTIVE = "na_executive";
-const Glib::ustring PAPER_NAME_LEGAL = "na_legal";
-
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- */
-enum Unit
-{
-  UNIT_PIXEL,
-  UNIT_POINTS,
-  UNIT_INCH,
-  UNIT_MM
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::Unit> : public Glib::Value_Enum<Gtk::Unit>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** PaperSize handles paper sizes. It uses the standard called "PWG 5101.1-2002 PWG: Standard for Media Standardized Names" 
- * to name the paper sizes (and to get the data for the page sizes). In addition to standard paper sizes, PaperSize allows 
- * to construct custom paper sizes with arbitrary dimensions.
- *
- * The PaperSize object stores not only the dimensions (width and height) of a paper size and its name, it also provides 
- * default print margins. 
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-class PaperSize
-{
-  // Cannot pass the _new function here, it must accept the 'name' argument.
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PaperSize CppObjectType;
-  typedef GtkPaperSize BaseObjectType;
-
-  static GType get_type() G_GNUC_CONST;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  PaperSize();
-
-  explicit PaperSize(GtkPaperSize* gobject, bool make_a_copy = true);
-
-  PaperSize(const PaperSize& other);
-  PaperSize& operator=(const PaperSize& other);
-
-  ~PaperSize();
-
-  void swap(PaperSize& other);
-
-  ///Provides access to the underlying C instance.
-  GtkPaperSize*       gobj()       { return gobject_; }
-
-  ///Provides access to the underlying C instance.
-  const GtkPaperSize* gobj() const { return gobject_; }
-
-  ///Provides access to the underlying C instance. The caller is responsible for freeing it. Use when directly setting fields in structs.
-  GtkPaperSize* gobj_copy() const;
-
-protected:
-  GtkPaperSize* gobject_;
-
-private:
-
-public:
-  // Allowing no argument works because gtk_paper_size_new() will call
-  // gtk_paper_size_get_default() in case of NULL.
-  /// If a name is not specified, a default value will be used.
-  explicit PaperSize(const Glib::ustring& name = "");
-  explicit PaperSize(const Glib::ustring& ppd_name, const Glib::ustring& ppd_display_name, double width, double height);
-  explicit PaperSize(const Glib::ustring& name, const Glib::ustring& display_name, double width, double height, Unit unit);
-
-  
-  bool equal(const PaperSize& other) const;
-
-  
-  Glib::ustring get_name() const;
-  
-  Glib::ustring get_display_name() const;
-  
-  Glib::ustring get_ppd_name() const;
-
-  
-  double get_width(Unit unit) const;
-  
-  double get_height(Unit unit) const;
-  
-  bool is_custom() const;
-
-  
-  void set_size(double width, double height, Unit unit);
-  
-  double get_default_top_margin(Unit unit) const;
-  
-  double get_default_bottom_margin(Unit unit) const;
-  
-  double get_default_left_margin(Unit unit) const;
-  
-  double get_default_right_margin(Unit unit) const;
-
-  
-  static Glib::ustring get_default();
-
-
-};
-
-/** @relates Gtk::PaperSize */
-inline bool operator==(const PaperSize& lhs, const PaperSize& rhs)
-  { return lhs.equal(rhs); }
-
-/** @relates Gtk::PaperSize */
-inline bool operator!=(const PaperSize& lhs, const PaperSize& rhs)
-  { return !lhs.equal(rhs); }
-
-} // namespace Gtk
-
-
-namespace Gtk
-{
-
-/** @relates Gtk::PaperSize
- * @param lhs The left-hand side
- * @param rhs The right-hand side
- */
-inline void swap(PaperSize& lhs, PaperSize& rhs)
-  { lhs.swap(rhs); }
-
-} // namespace Gtk
-
-namespace Glib
-{
-
-/** @relates Gtk::PaperSize
- * @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.
- */
-Gtk::PaperSize wrap(GtkPaperSize* object, bool take_copy = false);
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-template <>
-class Value<Gtk::PaperSize> : public Glib::Value_Boxed<Gtk::PaperSize>
-{};
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-} // namespace Glib
-
-
-#endif /* _GTKMM_PAPERSIZE_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/plug.cc b/libs/gtkmm2/gtk/gtkmm/plug.cc
index c11c8df831..befa8a4307 100644
--- a/libs/gtkmm2/gtk/gtkmm/plug.cc
+++ b/libs/gtkmm2/gtk/gtkmm/plug.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/plug.h>
 #include <gtkmm/private/plug_p.h>
 
@@ -61,15 +60,13 @@ Plug::Plug(const Glib::RefPtr<Gdk::Display>& display, GdkNativeWindow socket_id)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Plug_signal_embedded_info =
+const Glib::SignalProxyInfo Plug_signal_embedded_info =
 {
   "embedded",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -114,18 +111,10 @@ void Plug_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->embedded = &embedded_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Plug_Class::embedded_callback(GtkPlug* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -138,19 +127,15 @@ void Plug_Class::embedded_callback(GtkPlug* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_embedded();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -163,7 +148,6 @@ void Plug_Class::embedded_callback(GtkPlug* self)
       (*base->embedded)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Plug_Class::wrap_new(GObject* o)
@@ -217,7 +201,6 @@ Glib::SignalProxy0< void > Plug::signal_embedded()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Plug::on_embedded()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -227,10 +210,6 @@ void Gtk::Plug::on_embedded()
   if(base && base->embedded)
     (*base->embedded)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/plug.h b/libs/gtkmm2/gtk/gtkmm/plug.h
index 7877848e10..030bdc63c5 100644
--- a/libs/gtkmm2/gtk/gtkmm/plug.h
+++ b/libs/gtkmm2/gtk/gtkmm/plug.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_PLUG_H
 #define _GTKMM_PLUG_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -83,18 +82,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_embedded();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -118,11 +111,6 @@ public:
   GdkNativeWindow get_id() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %embedded()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_embedded();
 
 
@@ -139,8 +127,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Plug* wrap(GtkPlug* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_PLUG_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/printcontext.cc b/libs/gtkmm2/gtk/gtkmm/printcontext.cc
deleted file mode 100644
index 695bf4137d..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printcontext.cc
+++ /dev/null
@@ -1,230 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/printcontext.h>
-#include <gtkmm/private/printcontext_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprintcontext.h>
-
-namespace Gtk
-{
-
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::PrintContext> wrap(GtkPrintContext* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::PrintContext>( dynamic_cast<Gtk::PrintContext*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& PrintContext_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_ = &PrintContext_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(gtk_print_context_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void PrintContext_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PrintContext_Class::wrap_new(GObject* object)
-{
-  return new PrintContext((GtkPrintContext*)object);
-}
-
-
-/* The implementation: */
-
-GtkPrintContext* PrintContext::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-PrintContext::PrintContext(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-PrintContext::PrintContext(GtkPrintContext* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-PrintContext::~PrintContext()
-{}
-
-
-PrintContext::CppClassType PrintContext::printcontext_class_; // initialize static member
-
-GType PrintContext::get_type()
-{
-  return printcontext_class_.init().get_type();
-}
-
-GType PrintContext::get_base_type()
-{
-  return gtk_print_context_get_type();
-}
-
-
-Cairo::RefPtr<Cairo::Context> PrintContext::get_cairo_context()
-{
-  return Cairo::RefPtr<Cairo::Context>(new Cairo::Context(gtk_print_context_get_cairo_context(gobj()), false /* take ref */));
-}
-
-Cairo::RefPtr<const Cairo::Context> PrintContext::get_cairo_context() const
-{
-  return const_cast<PrintContext*>(this)->get_cairo_context();
-}
-
-Glib::RefPtr<PageSetup> PrintContext::get_page_setup()
-{
-
-  Glib::RefPtr<PageSetup> retvalue = Glib::wrap(gtk_print_context_get_page_setup(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const PageSetup> PrintContext::get_page_setup() const
-{
-  return const_cast<PrintContext*>(this)->get_page_setup();
-}
-
-double PrintContext::get_width() const
-{
-  return gtk_print_context_get_width(const_cast<GtkPrintContext*>(gobj()));
-}
-
-double PrintContext::get_height() const
-{
-  return gtk_print_context_get_height(const_cast<GtkPrintContext*>(gobj()));
-}
-
-double PrintContext::get_dpi_x() const
-{
-  return gtk_print_context_get_dpi_x(const_cast<GtkPrintContext*>(gobj()));
-}
-
-double PrintContext::get_dpi_y() const
-{
-  return gtk_print_context_get_dpi_y(const_cast<GtkPrintContext*>(gobj()));
-}
-
-Glib::RefPtr<Pango::FontMap> PrintContext::get_pango_fontmap()
-{
-
-  Glib::RefPtr<Pango::FontMap> retvalue = Glib::wrap(gtk_print_context_get_pango_fontmap(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const Pango::FontMap> PrintContext::get_pango_fontmap() const
-{
-  return const_cast<PrintContext*>(this)->get_pango_fontmap();
-}
-
-Glib::RefPtr<Pango::Context> PrintContext::create_pango_context()
-{
-
-  Glib::RefPtr<Pango::Context> retvalue = Glib::wrap(gtk_print_context_create_pango_context(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<Pango::Layout> PrintContext::create_pango_layout()
-{
-
-  Glib::RefPtr<Pango::Layout> retvalue = Glib::wrap(gtk_print_context_create_pango_layout(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-void PrintContext::set_cairo_context(const Cairo::RefPtr<Cairo::Context>& cr, double dpi_x, double dpi_y)
-{
-gtk_print_context_set_cairo_context(gobj(), (cr)->cobj(), dpi_x, dpi_y); 
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printcontext.h b/libs/gtkmm2/gtk/gtkmm/printcontext.h
deleted file mode 100644
index 662a86b3f2..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printcontext.h
+++ /dev/null
@@ -1,177 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTCONTEXT_H
-#define _GTKMM_PRINTCONTEXT_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/object.h>
-
-#include <cairomm/context.h>
-
-#include <pangomm/fontmap.h>
-#include <pangomm/context.h>
-#include <pangomm/layout.h>
-
-#include <gtkmm/pagesetup.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPrintContext GtkPrintContext;
-typedef struct _GtkPrintContextClass GtkPrintContextClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PrintContext_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** A PrintContext encapsulates context information that is required when
- * drawing pages for printing, such as the cairo context and important 
- * parameters like page size and resolution. It also lets you easily
- * create Pango::Layout and Pango::Context objects that match the font metrics 
- * of the cairo surface.
- * 
- * PrintContext objects gets passed to the begin-print, end-print, 
- * request-page-setup and draw-page signals on the PrintOperation.
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PrintContext : public Glib::Object
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef PrintContext CppObjectType;
-  typedef PrintContext_Class CppClassType;
-  typedef GtkPrintContext BaseObjectType;
-  typedef GtkPrintContextClass BaseClassType;
-
-private:  friend class PrintContext_Class;
-  static CppClassType printcontext_class_;
-
-private:
-  // noncopyable
-  PrintContext(const PrintContext&);
-  PrintContext& operator=(const PrintContext&);
-
-protected:
-  explicit PrintContext(const Glib::ConstructParams& construct_params);
-  explicit PrintContext(GtkPrintContext* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~PrintContext();
-
-#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 GObject.
-  GtkPrintContext*       gobj()       { return reinterpret_cast<GtkPrintContext*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkPrintContext* gobj() const { return reinterpret_cast<GtkPrintContext*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkPrintContext* gobj_copy();
-
-private:
-
-
-public:
-
-   
-  Cairo::RefPtr<Cairo::Context> get_cairo_context();
-  
-  Cairo::RefPtr<const Cairo::Context> get_cairo_context() const;
-
-  
-  Glib::RefPtr<PageSetup> get_page_setup();
-  
-  Glib::RefPtr<const PageSetup> get_page_setup() const;
-
-  
-  double get_width() const;
-  
-  double get_height() const;
-
-  
-  double get_dpi_x() const;
-  
-  double get_dpi_y() const;
-
-  
-  Glib::RefPtr<Pango::FontMap> get_pango_fontmap();
-  
-  Glib::RefPtr<const Pango::FontMap> get_pango_fontmap() const;
-
-  
-  Glib::RefPtr<Pango::Context> create_pango_context();
-  
-  Glib::RefPtr<Pango::Layout> create_pango_layout();
-
-  
-  void set_cairo_context(const Cairo::RefPtr<Cairo::Context>& cr, double dpi_x, double dpi_y);
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PrintContext
-   * @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<Gtk::PrintContext> wrap(GtkPrintContext* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_PRINTCONTEXT_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printer.cc b/libs/gtkmm2/gtk/gtkmm/printer.cc
deleted file mode 100644
index b9f049c9b3..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printer.cc
+++ /dev/null
@@ -1,393 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/printer.h>
-#include <gtkmm/private/printer_p.h>
-
-// -*- c++ -*-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprinter.h>
-
-// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
-
-static gboolean SignalProxy_Custom_gtk_callback(GtkPrinter* gtk_printer, gpointer data)
-{
-  const Gtk::SlotPrinterEnumerator* the_slot = static_cast<Gtk::SlotPrinterEnumerator*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    // Create a suitable C++ instance to pass to the C++ method;
-    Glib::RefPtr<Gtk::Printer> printer = Glib::wrap(gtk_printer);
-
-    return (*the_slot)(printer);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-    return false; // arbitrary default;
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_Custom_gtk_callback_destroy(void* data)
-{
-  delete static_cast<Gtk::SlotPrinterEnumerator*>(data);
-}
-
-namespace Gtk
-{
-
-bool Printer::equal(const Glib::RefPtr<Printer>& other) const
-{
-  return (static_cast<bool>(gtk_printer_compare(const_cast<GtkPrinter*>(this->gobj()),
-                                                const_cast<GtkPrinter*>(other->gobj()))));
-}
-
-void enumerate_printers(const SlotPrinterEnumerator& slot, bool wait)
-{
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  // It will be deleted when SignalProxy_Custom_gtk_callback_destroy() is called.
-  SlotPrinterEnumerator* slot_copy = new SlotPrinterEnumerator(slot);
-      
-  gtk_enumerate_printers(&SignalProxy_Custom_gtk_callback,
-                         slot_copy,
-                         &SignalProxy_Custom_gtk_callback_destroy,
-                         static_cast<int>(wait));
-}
-
-} // namespace Gtk
-
-namespace
-{
-
-
-static void Printer_signal_details_acquired_callback(GtkPrinter* self, gboolean p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,bool > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(p0
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo Printer_signal_details_acquired_info =
-{
-  "details_acquired",
-  (GCallback) &Printer_signal_details_acquired_callback,
-  (GCallback) &Printer_signal_details_acquired_callback
-};
-
-
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::Printer> wrap(GtkPrinter* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::Printer>( dynamic_cast<Gtk::Printer*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& Printer_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_ = &Printer_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(gtk_printer_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void Printer_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->details_acquired = &details_acquired_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Printer_Class::details_acquired_callback(GtkPrinter* self, gboolean 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_details_acquired(p0
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->details_acquired)
-      (*base->details_acquired)(self, p0);
-  }
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* Printer_Class::wrap_new(GObject* object)
-{
-  return new Printer((GtkPrinter*)object);
-}
-
-
-/* The implementation: */
-
-GtkPrinter* Printer::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-Printer::Printer(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-Printer::Printer(GtkPrinter* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-Printer::~Printer()
-{}
-
-
-Printer::CppClassType Printer::printer_class_; // initialize static member
-
-GType Printer::get_type()
-{
-  return printer_class_.init().get_type();
-}
-
-GType Printer::get_base_type()
-{
-  return gtk_printer_get_type();
-}
-
-
-Glib::ustring Printer::get_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_printer_get_name(const_cast<GtkPrinter*>(gobj())));
-}
-
-Glib::ustring Printer::get_state_message() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_printer_get_state_message(const_cast<GtkPrinter*>(gobj())));
-}
-
-Glib::ustring Printer::get_description() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_printer_get_description(const_cast<GtkPrinter*>(gobj())));
-}
-
-Glib::ustring Printer::get_location() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_printer_get_location(const_cast<GtkPrinter*>(gobj())));
-}
-
-Glib::ustring Printer::get_icon_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_printer_get_icon_name(const_cast<GtkPrinter*>(gobj())));
-}
-
-int Printer::get_job_count() const
-{
-  return gtk_printer_get_job_count(const_cast<GtkPrinter*>(gobj()));
-}
-
-bool Printer::is_active() const
-{
-  return gtk_printer_is_active(const_cast<GtkPrinter*>(gobj()));
-}
-
-bool Printer::is_virtual() const
-{
-  return gtk_printer_is_virtual(const_cast<GtkPrinter*>(gobj()));
-}
-
-bool Printer::is_default() const
-{
-  return gtk_printer_is_default(const_cast<GtkPrinter*>(gobj()));
-}
-
-bool Printer::accepts_pdf() const
-{
-  return gtk_printer_accepts_pdf(const_cast<GtkPrinter*>(gobj()));
-}
-
-bool Printer::accepts_ps() const
-{
-  return gtk_printer_accepts_ps(const_cast<GtkPrinter*>(gobj()));
-}
-
-
-Glib::SignalProxy1< void,bool > Printer::signal_details_acquired()
-{
-  return Glib::SignalProxy1< void,bool >(this, &Printer_signal_details_acquired_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> Printer::property_name() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> Printer::property_is_virtual() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "is-virtual");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> Printer::property_state_message() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "state-message");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> Printer::property_location() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "location");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> Printer::property_icon_name() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "icon-name");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> Printer::property_job_count() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "job-count");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> Printer::property_accepts_pdf() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "accepts-pdf");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> Printer::property_accepts_ps() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "accepts-ps");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Gtk::Printer::on_details_acquired(bool success)
-{
-  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->details_acquired)
-    (*base->details_acquired)(gobj(),static_cast<int>(success));
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printer.h b/libs/gtkmm2/gtk/gtkmm/printer.h
deleted file mode 100644
index 1ca588d020..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printer.h
+++ /dev/null
@@ -1,290 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTER_H
-#define _GTKMM_PRINTER_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/object.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPrinter GtkPrinter;
-typedef struct _GtkPrinterClass GtkPrinterClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class Printer_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** A Printer object represents a printer. You only need to deal directly with printers if you use the 
- * non-portable PrintUnixDialog API.
- *
- * A Printer object allows to get status information about the printer, such as its description, its location, 
- * the number of queued jobs, etc. Most importantly, a Printer object can be used to create a PrintJob object, 
- * which lets you print to the printer.
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class Printer : public Glib::Object
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef Printer CppObjectType;
-  typedef Printer_Class CppClassType;
-  typedef GtkPrinter BaseObjectType;
-  typedef GtkPrinterClass BaseClassType;
-
-private:  friend class Printer_Class;
-  static CppClassType printer_class_;
-
-private:
-  // noncopyable
-  Printer(const Printer&);
-  Printer& operator=(const Printer&);
-
-protected:
-  explicit Printer(const Glib::ConstructParams& construct_params);
-  explicit Printer(GtkPrinter* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~Printer();
-
-#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 GObject.
-  GtkPrinter*       gobj()       { return reinterpret_cast<GtkPrinter*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkPrinter* gobj() const { return reinterpret_cast<GtkPrinter*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkPrinter* gobj_copy();
-
-private:
-
-  //This is not available in on Win32.
-//This source file will not be compiled,
-//and the class will not be registered in wrap_init.h or wrap_init.cc
-
-
-public:
-  //TODO: _WRAP_CREATE() - probably not, it's only accessible through PrintUnixDialog + GtkPrintBackend should be ignored
-  
-  //TODO: I think these are not needed as well, and that Printer should generally be read-only - marko.
-  
-  
-  bool equal(const Glib::RefPtr<Printer>& other) const;
-
-  //TODO: _WRAP_METHOD(Glib::RefPtr<PrintBackend> get_backend(), gtk_printer_get_backend. refreturn)
-  //_WRAP_METHOD(Glib::RefPtr<const PrintBackend> get_backend() const, gtk_printer_get_backend, refreturn, constversion)
-  
-  Glib::ustring get_name() const;
-  
-  Glib::ustring get_state_message() const;
-  
-  Glib::ustring get_description() const;
-  
-  Glib::ustring get_location() const;
-  
-  Glib::ustring get_icon_name() const;
-  
-  int get_job_count() const;
-  
-  bool is_active() const;
-  
-  bool is_virtual() const;
-  
-  bool is_default() const;
-  
-  bool accepts_pdf() const;
-  
-  bool accepts_ps() const;
-  
-  
-/**
-   * @par Prototype:
-   * <tt>void %details_acquired(bool success)</tt>
-   */
-
-  Glib::SignalProxy1< void,bool > signal_details_acquired();
-
-  
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of the printer.
-   *
-   * 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_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  //TODO: _WRAP_PROPERTY("backend", Glib::RefPtr<PrintBackend>)
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** FALSE if this represents a real hardware printer.
-   *
-   * 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_is_virtual() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** String giving the current state of the printer.
-   *
-   * 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_state_message() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The location of the printer.
-   *
-   * 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_location() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The icon name to use for the printer.
-   *
-   * 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_icon_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of jobs queued in the printer.
-   *
-   * 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_job_count() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if this printer can accept PDF.
-   *
-   * 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_accepts_pdf() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if this printer can accept PostScript.
-   *
-   * 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_accepts_ps() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual void on_details_acquired(bool success);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-/** @relates Gtk::Printer */
-inline bool operator==(const Glib::RefPtr<Printer>& lhs, const Glib::RefPtr<Printer>& rhs)
-  { return lhs->equal(rhs); }
-
-/** @relates Gtk::Printer */
-inline bool operator!=(const Glib::RefPtr<Printer>& lhs, const Glib::RefPtr<Printer>& rhs)
-  { return !lhs->equal(rhs); }
-
-/** For example, 
- * bool on_enumerate_printers(const Glib::RefPtr<Printer>& printer);
- *
- * TODO: document return value.
- *
- * @relates Gtk::Printer
- */
-typedef sigc::slot< bool, const Glib::RefPtr<Printer>& > SlotPrinterEnumerator;
-
-/** TODO: document this
- *
- * @relates Gtk::Printer
- */
-void enumerate_printers(const SlotPrinterEnumerator& slot, bool wait = true);
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::Printer
-   * @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<Gtk::Printer> wrap(GtkPrinter* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_PRINTER_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printjob.cc b/libs/gtkmm2/gtk/gtkmm/printjob.cc
deleted file mode 100644
index 89894d7006..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printjob.cc
+++ /dev/null
@@ -1,389 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/printjob.h>
-#include <gtkmm/private/printjob_p.h>
-
-// -*- c++ -*-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprintjob.h>
-#include <gtk/gtktypebuiltins.h>
-
-// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
-
-static void SignalProxy_Custom_gtk_callback(GtkPrintJob* print_job, gpointer data, GError* gerror)
-{
-  const Gtk::PrintJob::SlotPrintJobComplete* the_slot = static_cast<Gtk::PrintJob::SlotPrintJobComplete*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
-    // Create a suitable C++ instance to pass to the C++ method;
-    Glib::RefPtr<Gtk::PrintJob> job = Glib::wrap(print_job);
-
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    if (gerror) Glib::Error::throw_exception(gerror);
-    (*the_slot)(job);
-    #else
-    std::auto_ptr<Glib::Error> error = Glib::Error::throw_exception(gerror);
-    (*the_slot)(job, error);
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_Custom_gtk_callback_destroy(void* data)
-{
-  delete static_cast<Gtk::PrintJob::SlotPrintJobComplete*>(data);
-}
-
-namespace Gtk
-{
-
-void PrintJob::send(const SlotPrintJobComplete& slot)
-{
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  // It will be deleted when SignalProxy_Custom_gtk_callback_destroy() is called.
-  SlotPrintJobComplete* slot_copy = new SlotPrintJobComplete(slot);
-      
-  gtk_print_job_send(gobj(), &SignalProxy_Custom_gtk_callback, slot_copy, &SignalProxy_Custom_gtk_callback_destroy);
-}
-
-} // namespace Gtk
-
-namespace
-{
-
-
-static const Glib::SignalProxyInfo PrintJob_signal_status_changed_info =
-{
-  "status_changed",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-} // anonymous namespace
-
-// static
-GType Glib::Value<Gtk::PrintCapabilities>::value_type()
-{
-  return gtk_print_capabilities_get_type();
-}
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::PrintJob> wrap(GtkPrintJob* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::PrintJob>( dynamic_cast<Gtk::PrintJob*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& PrintJob_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_ = &PrintJob_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(gtk_print_job_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void PrintJob_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->status_changed = &status_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void PrintJob_Class::status_changed_callback(GtkPrintJob* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_status_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->status_changed)
-      (*base->status_changed)(self);
-  }
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PrintJob_Class::wrap_new(GObject* object)
-{
-  return new PrintJob((GtkPrintJob*)object);
-}
-
-
-/* The implementation: */
-
-GtkPrintJob* PrintJob::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-PrintJob::PrintJob(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-PrintJob::PrintJob(GtkPrintJob* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-PrintJob::~PrintJob()
-{}
-
-
-PrintJob::CppClassType PrintJob::printjob_class_; // initialize static member
-
-GType PrintJob::get_type()
-{
-  return printjob_class_.init().get_type();
-}
-
-GType PrintJob::get_base_type()
-{
-  return gtk_print_job_get_type();
-}
-
-
-PrintJob::PrintJob(const Glib::ustring& title, const Glib::RefPtr<Printer>& printer, const Glib::RefPtr<PrintSettings>& settings, const Glib::RefPtr<PageSetup>& page_setup)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(printjob_class_.init(), "title", title.c_str(), "printer", Glib::unwrap(printer), "settings", Glib::unwrap(settings), "page_setup", Glib::unwrap(page_setup), (char*) 0))
-{
-  }
-
-Glib::RefPtr<PrintJob> PrintJob::create(const Glib::ustring& title, const Glib::RefPtr<Printer>& printer, const Glib::RefPtr<PrintSettings>& settings, const Glib::RefPtr<PageSetup>& page_setup)
-{
-  return Glib::RefPtr<PrintJob>( new PrintJob(title, printer, settings, page_setup) );
-}
-Glib::RefPtr<PrintSettings> PrintJob::get_settings()
-{
-
-  Glib::RefPtr<PrintSettings> retvalue = Glib::wrap(gtk_print_job_get_settings(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const PrintSettings> PrintJob::get_settings() const
-{
-  return const_cast<PrintJob*>(this)->get_settings();
-}
-
-Glib::RefPtr<Printer> PrintJob::get_printer()
-{
-
-  Glib::RefPtr<Printer> retvalue = Glib::wrap(gtk_print_job_get_printer(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const Printer> PrintJob::get_printer() const
-{
-  return const_cast<PrintJob*>(this)->get_printer();
-}
-
-Glib::ustring PrintJob::get_title() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_job_get_title(const_cast<GtkPrintJob*>(gobj())));
-}
-
-PrintStatus PrintJob::get_status() const
-{
-  return (PrintStatus)gtk_print_job_get_status(const_cast<GtkPrintJob*>(gobj()));
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-void PrintJob::set_source_file(const std::string& filename)
-#else
-void PrintJob::set_source_file(const std::string& filename, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  gtk_print_job_set_source_file(gobj(), filename.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-Cairo::RefPtr<Cairo::Surface> PrintJob::get_surface()
-#else
-Cairo::RefPtr<Cairo::Surface> PrintJob::get_surface(std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Cairo::RefPtr<Cairo::Surface> retvalue = Cairo::RefPtr<Cairo::Surface>(new Cairo::Surface(gtk_print_job_get_surface(gobj(), &(gerror)), false /* take reference */));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-void PrintJob::set_track_print_status(bool track_status)
-{
-gtk_print_job_set_track_print_status(gobj(), static_cast<int>(track_status)); 
-}
-
-bool PrintJob::get_track_print_status() const
-{
-  return gtk_print_job_get_track_print_status(const_cast<GtkPrintJob*>(gobj()));
-}
-
-
-Glib::SignalProxy0< void > PrintJob::signal_status_changed()
-{
-  return Glib::SignalProxy0< void >(this, &PrintJob_signal_status_changed_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> PrintJob::property_title() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Printer> > PrintJob::property_printer() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Printer> >(this, "printer");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PrintSettings> > PrintJob::property_settings() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PrintSettings> >(this, "settings");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PageSetup> > PrintJob::property_page_setup() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PageSetup> >(this, "page-setup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Gtk::PrintJob::on_status_changed()
-{
-  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->status_changed)
-    (*base->status_changed)(gobj());
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printjob.h b/libs/gtkmm2/gtk/gtkmm/printjob.h
deleted file mode 100644
index 9da6a9e565..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printjob.h
+++ /dev/null
@@ -1,331 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTJOB_H
-#define _GTKMM_PRINTJOB_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/object.h>
-#include <gtkmm/pagesetup.h>
-#include <gtkmm/printer.h>
-#include <gtkmm/printoperation.h>
-#include <gtkmm/printsettings.h>
-#include <cairomm/surface.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPrintJob GtkPrintJob;
-typedef struct _GtkPrintJobClass GtkPrintJobClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PrintJob_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- * @par Bitwise operators:
- * <tt>%PrintCapabilities operator|(PrintCapabilities, PrintCapabilities)</tt><br>
- * <tt>%PrintCapabilities operator&(PrintCapabilities, PrintCapabilities)</tt><br>
- * <tt>%PrintCapabilities operator^(PrintCapabilities, PrintCapabilities)</tt><br>
- * <tt>%PrintCapabilities operator~(PrintCapabilities)</tt><br>
- * <tt>%PrintCapabilities& operator|=(PrintCapabilities&, PrintCapabilities)</tt><br>
- * <tt>%PrintCapabilities& operator&=(PrintCapabilities&, PrintCapabilities)</tt><br>
- * <tt>%PrintCapabilities& operator^=(PrintCapabilities&, PrintCapabilities)</tt><br>
- */
-enum PrintCapabilities
-{
-  PRINT_CAPABILITY_PAGE_SET = 1 << 0,
-  PRINT_CAPABILITY_COPIES = 1 << 1,
-  PRINT_CAPABILITY_COLLATE = 1 << 2,
-  PRINT_CAPABILITY_REVERSE = 1 << 3,
-  PRINT_CAPABILITY_SCALE = 1 << 4,
-  PRINT_CAPABILITY_GENERATE_PDF = 1 << 5,
-  PRINT_CAPABILITY_GENERATE_PS = 1 << 6
-};
-
-/** @ingroup gtkmmEnums */
-inline PrintCapabilities operator|(PrintCapabilities lhs, PrintCapabilities rhs)
-  { return static_cast<PrintCapabilities>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
-
-/** @ingroup gtkmmEnums */
-inline PrintCapabilities operator&(PrintCapabilities lhs, PrintCapabilities rhs)
-  { return static_cast<PrintCapabilities>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
-
-/** @ingroup gtkmmEnums */
-inline PrintCapabilities operator^(PrintCapabilities lhs, PrintCapabilities rhs)
-  { return static_cast<PrintCapabilities>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
-
-/** @ingroup gtkmmEnums */
-inline PrintCapabilities operator~(PrintCapabilities flags)
-  { return static_cast<PrintCapabilities>(~static_cast<unsigned>(flags)); }
-
-/** @ingroup gtkmmEnums */
-inline PrintCapabilities& operator|=(PrintCapabilities& lhs, PrintCapabilities rhs)
-  { return (lhs = static_cast<PrintCapabilities>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
-
-/** @ingroup gtkmmEnums */
-inline PrintCapabilities& operator&=(PrintCapabilities& lhs, PrintCapabilities rhs)
-  { return (lhs = static_cast<PrintCapabilities>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
-
-/** @ingroup gtkmmEnums */
-inline PrintCapabilities& operator^=(PrintCapabilities& lhs, PrintCapabilities rhs)
-  { return (lhs = static_cast<PrintCapabilities>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintCapabilities> : public Glib::Value_Flags<Gtk::PrintCapabilities>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** A PrintJob object represents a job that is sent to a printer. You only need to deal 
- * directly with print jobs if you  use the non-portable PrintUnixDialog API.
- * 
- * Use get_surface() to obtain the cairo surface onto which the pages must be drawn. 
- * Use send() to send the finished job to the printer.If you don't use cairo then 
- * PrintJob also supports printing of manually generated postscript, via set_source_file().
- * 
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PrintJob : public Glib::Object
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef PrintJob CppObjectType;
-  typedef PrintJob_Class CppClassType;
-  typedef GtkPrintJob BaseObjectType;
-  typedef GtkPrintJobClass BaseClassType;
-
-private:  friend class PrintJob_Class;
-  static CppClassType printjob_class_;
-
-private:
-  // noncopyable
-  PrintJob(const PrintJob&);
-  PrintJob& operator=(const PrintJob&);
-
-protected:
-  explicit PrintJob(const Glib::ConstructParams& construct_params);
-  explicit PrintJob(GtkPrintJob* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~PrintJob();
-
-#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 GObject.
-  GtkPrintJob*       gobj()       { return reinterpret_cast<GtkPrintJob*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkPrintJob* gobj() const { return reinterpret_cast<GtkPrintJob*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkPrintJob* gobj_copy();
-
-private:
-
-  //This is not available in on Win32.
-//This source file will not be compiled,
-//and the class will not be registered in wrap_init.h or wrap_init.cc
-
-
-protected:
-  explicit PrintJob(const Glib::ustring& title, const Glib::RefPtr<Printer>& printer, const Glib::RefPtr<PrintSettings>& settings, const Glib::RefPtr<PageSetup>& page_setup);
-
-public:
-  
-  static Glib::RefPtr<PrintJob> create(const Glib::ustring& title, const Glib::RefPtr<Printer>& printer, const Glib::RefPtr<PrintSettings>& settings, const Glib::RefPtr<PageSetup>& page_setup);
-
-
-  Glib::RefPtr<PrintSettings> get_settings();
-  
-  Glib::RefPtr<const PrintSettings> get_settings() const;
-
-  
-  Glib::RefPtr<Printer> get_printer();
-  
-  Glib::RefPtr<const Printer> get_printer() const;
-
-  
-  Glib::ustring get_title() const;
-  
-  PrintStatus get_status() const;
-   // this appears in gtkprinter-private.h
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  void set_source_file(const std::string& filename);
-#else
-  void set_source_file(const std::string& filename, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Cairo::RefPtr<Cairo::Surface> get_surface();
-#else
-  Cairo::RefPtr<Cairo::Surface> get_surface(std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  //TODO: _WRAP_METHOD(Cairo::RefPtr<const Cairo::Surface> get_surface() const, gtk_print_job_get_surface, constversion, errthrow)
-
-  
-  void set_track_print_status(bool track_status = true);
-  
-  bool get_track_print_status() const;
-
-  
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  /** For example, 
-   * void on_print_job_complete(const Glib::RefPtr<PrintJob>& job);
-   *
-   * @throws exception
-   */
-  typedef sigc::slot< void, const Glib::RefPtr<PrintJob>& > SlotPrintJobComplete;
-  #else
-  /** For example, 
-   * void on_print_job_complete(const Glib::RefPtr<PrintJob>& job, std::auto_ptr<Glib::Error>& error);
-   */
-  typedef sigc::slot< void, const Glib::RefPtr<PrintJob>&, std::auto_ptr<Glib::Error>& > SlotPrintJobComplete;
-  #endif
-
-  /** TODO: document this
-   *
-   */
-  void send(const SlotPrintJobComplete& slot);
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %status_changed()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_status_changed();
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Title of the print job.
-   *
-   * 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_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Printer to print the job to.
-   *
-   * 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<Printer> > property_printer() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Printer settings.
-   *
-   * 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<PrintSettings> > property_settings() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Page Setup.
-   *
-   * 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<PageSetup> > property_page_setup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual void on_status_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PrintJob
-   * @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<Gtk::PrintJob> wrap(GtkPrintJob* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_PRINTJOB_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printoperation.cc b/libs/gtkmm2/gtk/gtkmm/printoperation.cc
deleted file mode 100644
index b3181b3a62..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printoperation.cc
+++ /dev/null
@@ -1,1549 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/printoperation.h>
-#include <gtkmm/private/printoperation_p.h>
-
-// -*- c++ -*-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprintoperation.h>
-
-// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
-
-static void
-SignalProxy_PrintSetupDone_gtk_callback(GtkPageSetup* page_setup, gpointer data)
-{
-  const Gtk::SlotPrintSetupDone* the_slot = static_cast<Gtk::SlotPrintSetupDone*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    Glib::RefPtr<Gtk::PageSetup> ps = Glib::wrap(page_setup);
-    (*the_slot)(ps);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch (...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  delete the_slot;
-}
-
-namespace Gtk
-{
-
-PrintOperationResult
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-PrintOperation::run(PrintOperationAction action)
-#else
-PrintOperation::run(PrintOperationAction action, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  PrintOperationResult res =
-    (PrintOperationResult)gtk_print_operation_run(this->gobj(), (GtkPrintOperationAction)action, 0, &gerror);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if (res == PRINT_OPERATION_RESULT_ERROR)
-  {
-    gtk_print_operation_get_error(this->gobj(), &gerror);
-    ::Glib::Error::throw_exception(gerror);
-  }
-  #else
-  if (res == PRINT_OPERATION_RESULT_ERROR)
-  {
-    gtk_print_operation_get_error(this->gobj(), &gerror);
-    error = ::Glib::Error::throw_exception(gerror);
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return res;
-}
-
-Glib::RefPtr<PageSetup>
-run_page_setup_dialog(Window& parent,
-                      const Glib::RefPtr<const PageSetup>& page_setup,
-                      const Glib::RefPtr<const PrintSettings>& print_settings)
-{
-  // Specify the exact type with template specialization, to avoid possible
-  // ambiguities between the const and non-const versions of unwrap() reported
-  // by Sun's compiler (specifying unwrap<const Object> was reported
-  // not to work):
-  return Glib::wrap(
-    gtk_print_run_page_setup_dialog(
-      parent.gobj(),
-      const_cast<GtkPageSetup*>(Glib::unwrap<PageSetup>(page_setup)),
-      const_cast<GtkPrintSettings*>(Glib::unwrap<PrintSettings>(print_settings))));
-
-}
-
-void
-run_page_setup_dialog_async(Window& parent,
-                            const Glib::RefPtr<const PageSetup>& page_setup,
-                            const Glib::RefPtr<const PrintSettings>& print_settings,
-                            const SlotPrintSetupDone& slot)
-{
-  SlotPrintSetupDone* slot_copy = new SlotPrintSetupDone(slot);
-
-  // Specify the exact type with template specialization, to avoid possible
-  // ambiguities between the const and non-const versions of unwrap() reported
-  // by Sun's compiler (specifying unwrap<const Object> was reported
-  // not to work):
-  gtk_print_run_page_setup_dialog_async(
-    parent.gobj(),
-    const_cast<GtkPageSetup*>(Glib::unwrap<PageSetup>(page_setup)),
-    const_cast<GtkPrintSettings*>(Glib::unwrap<PrintSettings>(print_settings)),
-    &SignalProxy_PrintSetupDone_gtk_callback,
-    slot_copy);
-}
-
-} // namespace Gtk
-
-namespace
-{
-
-
-static void PrintOperation_signal_done_callback(GtkPrintOperation* self, GtkPrintOperationResult p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,PrintOperationResult > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))((PrintOperationResult)p0
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_done_info =
-{
-  "done",
-  (GCallback) &PrintOperation_signal_done_callback,
-  (GCallback) &PrintOperation_signal_done_callback
-};
-
-
-static void PrintOperation_signal_begin_print_callback(GtkPrintOperation* self, GtkPrintContext* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintContext>& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_begin_print_info =
-{
-  "begin_print",
-  (GCallback) &PrintOperation_signal_begin_print_callback,
-  (GCallback) &PrintOperation_signal_begin_print_callback
-};
-
-
-static gboolean PrintOperation_signal_paginate_callback(GtkPrintOperation* self, GtkPrintContext* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< bool,const Glib::RefPtr<PrintContext>& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-
-static gboolean PrintOperation_signal_paginate_notify_callback(GtkPrintOperation* self, GtkPrintContext* p0, void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintContext>& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_paginate_info =
-{
-  "paginate",
-  (GCallback) &PrintOperation_signal_paginate_callback,
-  (GCallback) &PrintOperation_signal_paginate_notify_callback
-};
-
-
-static void PrintOperation_signal_request_page_setup_callback(GtkPrintOperation* self, GtkPrintContext* p0,gint p1,GtkPageSetup* p2,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintContext>&,int,const Glib::RefPtr<PageSetup>& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-, p1
-, Glib::wrap(p2, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_request_page_setup_info =
-{
-  "request_page_setup",
-  (GCallback) &PrintOperation_signal_request_page_setup_callback,
-  (GCallback) &PrintOperation_signal_request_page_setup_callback
-};
-
-
-static void PrintOperation_signal_draw_page_callback(GtkPrintOperation* self, GtkPrintContext* p0,gint p1,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintContext>&,int > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-, p1
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_draw_page_info =
-{
-  "draw_page",
-  (GCallback) &PrintOperation_signal_draw_page_callback,
-  (GCallback) &PrintOperation_signal_draw_page_callback
-};
-
-
-static void PrintOperation_signal_end_print_callback(GtkPrintOperation* self, GtkPrintContext* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintContext>& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_end_print_info =
-{
-  "end_print",
-  (GCallback) &PrintOperation_signal_end_print_callback,
-  (GCallback) &PrintOperation_signal_end_print_callback
-};
-
-
-static const Glib::SignalProxyInfo PrintOperation_signal_status_changed_info =
-{
-  "status_changed",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-static GtkWidget* PrintOperation_signal_create_custom_widget_callback(GtkPrintOperation* self, void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< Widget* > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        return (GtkWidget*)Glib::unwrap((*static_cast<SlotType*>(slot))());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef GtkWidget* RType;
-  return RType();
-}
-
-static GtkWidget* PrintOperation_signal_create_custom_widget_notify_callback(GtkPrintOperation* self,  void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef GtkWidget* RType;
-  return RType();
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_create_custom_widget_info =
-{
-  "create_custom_widget",
-  (GCallback) &PrintOperation_signal_create_custom_widget_callback,
-  (GCallback) &PrintOperation_signal_create_custom_widget_notify_callback
-};
-
-
-static void PrintOperation_signal_custom_widget_apply_callback(GtkPrintOperation* self, GtkWidget* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,Widget* > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_custom_widget_apply_info =
-{
-  "custom_widget_apply",
-  (GCallback) &PrintOperation_signal_custom_widget_apply_callback,
-  (GCallback) &PrintOperation_signal_custom_widget_apply_callback
-};
-
-
-static gboolean PrintOperation_signal_preview_callback(GtkPrintOperation* self, GtkPrintOperationPreview* p0,GtkPrintContext* p1,GtkWindow* p2,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< bool,const Glib::RefPtr<PrintOperationPreview>&,const Glib::RefPtr<PrintContext>&,Window* > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-, Glib::wrap(p1, true)
-, Glib::wrap(p2)
-));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-
-static gboolean PrintOperation_signal_preview_notify_callback(GtkPrintOperation* self, GtkPrintOperationPreview* p0,GtkPrintContext* p1,GtkWindow* p2, void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintOperationPreview>&,const Glib::RefPtr<PrintContext>&,Window* > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-, Glib::wrap(p1, true)
-, Glib::wrap(p2)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-
-static const Glib::SignalProxyInfo PrintOperation_signal_preview_info =
-{
-  "preview",
-  (GCallback) &PrintOperation_signal_preview_callback,
-  (GCallback) &PrintOperation_signal_preview_notify_callback
-};
-
-
-} // anonymous namespace
-
-// static
-GType Glib::Value<Gtk::PrintStatus>::value_type()
-{
-  return gtk_print_status_get_type();
-}
-
-// static
-GType Glib::Value<Gtk::PrintOperationResult>::value_type()
-{
-  return gtk_print_operation_result_get_type();
-}
-
-// static
-GType Glib::Value<Gtk::PrintOperationAction>::value_type()
-{
-  return gtk_print_operation_action_get_type();
-}
-
-
-Gtk::PrintError::PrintError(Gtk::PrintError::Code error_code, const Glib::ustring& error_message)
-:
-  Glib::Error (GTK_PRINT_ERROR, error_code, error_message)
-{}
-
-Gtk::PrintError::PrintError(GError* gobject)
-:
-  Glib::Error (gobject)
-{}
-
-Gtk::PrintError::Code Gtk::PrintError::code() const
-{
-  return static_cast<Code>(Glib::Error::code());
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-void Gtk::PrintError::throw_func(GError* gobject)
-{
-  throw Gtk::PrintError(gobject);
-}
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Gtk::PrintError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Gtk::PrintError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-// static
-GType Glib::Value<Gtk::PrintError::Code>::value_type()
-{
-  return gtk_print_error_get_type();
-}
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::PrintOperation> wrap(GtkPrintOperation* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::PrintOperation>( dynamic_cast<Gtk::PrintOperation*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& PrintOperation_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_ = &PrintOperation_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(gtk_print_operation_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  PrintOperationPreview::add_interface(get_type());
-  }
-
-  return *this;
-}
-
-void PrintOperation_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->done = &done_callback;
-  klass->begin_print = &begin_print_callback;
-  klass->paginate = &paginate_callback;
-  klass->request_page_setup = &request_page_setup_callback;
-  klass->draw_page = &draw_page_callback;
-  klass->end_print = &end_print_callback;
-  klass->status_changed = &status_changed_callback;
-  klass->create_custom_widget = &create_custom_widget_callback;
-  klass->custom_widget_apply = &custom_widget_apply_callback;
-  klass->preview = &preview_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void PrintOperation_Class::done_callback(GtkPrintOperation* self, GtkPrintOperationResult 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_done((PrintOperationResult)p0
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->done)
-      (*base->done)(self, p0);
-  }
-}
-void PrintOperation_Class::begin_print_callback(GtkPrintOperation* self, GtkPrintContext* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_begin_print(Glib::wrap(p0, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->begin_print)
-      (*base->begin_print)(self, p0);
-  }
-}
-gboolean PrintOperation_Class::paginate_callback(GtkPrintOperation* self, GtkPrintContext* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      return static_cast<int>(obj->on_paginate(Glib::wrap(p0, true)
-));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->paginate)
-      return (*base->paginate)(self, p0);
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-void PrintOperation_Class::request_page_setup_callback(GtkPrintOperation* self, GtkPrintContext* p0, gint p1, GtkPageSetup* p2)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_request_page_setup(Glib::wrap(p0, true)
-, p1
-, Glib::wrap(p2, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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_page_setup)
-      (*base->request_page_setup)(self, p0, p1, p2);
-  }
-}
-void PrintOperation_Class::draw_page_callback(GtkPrintOperation* self, GtkPrintContext* p0, gint p1)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_draw_page(Glib::wrap(p0, true)
-, p1
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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_page)
-      (*base->draw_page)(self, p0, p1);
-  }
-}
-void PrintOperation_Class::end_print_callback(GtkPrintOperation* self, GtkPrintContext* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_end_print(Glib::wrap(p0, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->end_print)
-      (*base->end_print)(self, p0);
-  }
-}
-void PrintOperation_Class::status_changed_callback(GtkPrintOperation* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_status_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->status_changed)
-      (*base->status_changed)(self);
-  }
-}
-GtkWidget* PrintOperation_Class::create_custom_widget_callback(GtkPrintOperation* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      return (GtkWidget*)Glib::unwrap(obj->on_create_custom_widget());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->create_custom_widget)
-      return (*base->create_custom_widget)(self);
-  }
-
-  typedef GtkWidget* RType;
-  return RType();
-}
-void PrintOperation_Class::custom_widget_apply_callback(GtkPrintOperation* self, GtkWidget* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_custom_widget_apply(Glib::wrap(p0)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->custom_widget_apply)
-      (*base->custom_widget_apply)(self, p0);
-  }
-}
-gboolean PrintOperation_Class::preview_callback(GtkPrintOperation* self, GtkPrintOperationPreview* p0, GtkPrintContext* p1, GtkWindow* p2)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      return static_cast<int>(obj->on_preview(Glib::wrap(p0, true)
-, Glib::wrap(p1, true)
-, Glib::wrap(p2)
-));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->preview)
-      return (*base->preview)(self, p0, p1, p2);
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PrintOperation_Class::wrap_new(GObject* object)
-{
-  return new PrintOperation((GtkPrintOperation*)object);
-}
-
-
-/* The implementation: */
-
-GtkPrintOperation* PrintOperation::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-PrintOperation::PrintOperation(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-PrintOperation::PrintOperation(GtkPrintOperation* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-PrintOperation::~PrintOperation()
-{}
-
-
-PrintOperation::CppClassType PrintOperation::printoperation_class_; // initialize static member
-
-GType PrintOperation::get_type()
-{
-  return printoperation_class_.init().get_type();
-}
-
-GType PrintOperation::get_base_type()
-{
-  return gtk_print_operation_get_type();
-}
-
-
-PrintOperation::PrintOperation()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(printoperation_class_.init()))
-{
-  }
-
-Glib::RefPtr<PrintOperation> PrintOperation::create()
-{
-  return Glib::RefPtr<PrintOperation>( new PrintOperation() );
-}
-void PrintOperation::set_default_page_setup(const Glib::RefPtr<PageSetup>& default_page_setup)
-{
-gtk_print_operation_set_default_page_setup(gobj(), Glib::unwrap(default_page_setup)); 
-}
-
-Glib::RefPtr<PageSetup> PrintOperation::get_default_page_setup() const
-{
-  return Glib::wrap(gtk_print_operation_get_default_page_setup(const_cast<GtkPrintOperation*>(gobj())));
-}
-
-void PrintOperation::set_print_settings(const Glib::RefPtr<PrintSettings>& print_settings)
-{
-gtk_print_operation_set_print_settings(gobj(), Glib::unwrap(print_settings)); 
-}
-
-Glib::RefPtr<PrintSettings> PrintOperation::get_print_settings() const
-{
-
-  Glib::RefPtr<PrintSettings> retvalue = Glib::wrap(gtk_print_operation_get_print_settings(const_cast<GtkPrintOperation*>(gobj())));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-void PrintOperation::set_job_name(const Glib::ustring& job_name)
-{
-gtk_print_operation_set_job_name(gobj(), job_name.c_str()); 
-}
-
-void PrintOperation::set_n_pages(int n_pages)
-{
-gtk_print_operation_set_n_pages(gobj(), n_pages); 
-}
-
-void PrintOperation::set_current_page(int current_page)
-{
-gtk_print_operation_set_current_page(gobj(), current_page); 
-}
-
-void PrintOperation::set_use_full_page(bool use_full_page)
-{
-gtk_print_operation_set_use_full_page(gobj(), static_cast<int>(use_full_page)); 
-}
-
-void PrintOperation::set_unit(Unit unit)
-{
-gtk_print_operation_set_unit(gobj(), ((GtkUnit)(unit))); 
-}
-
-void PrintOperation::set_export_filename(const std::string& filename)
-{
-gtk_print_operation_set_export_filename(gobj(), filename.c_str()); 
-}
-
-void PrintOperation::set_track_print_status(bool track_status)
-{
-gtk_print_operation_set_track_print_status(gobj(), static_cast<int>(track_status)); 
-}
-
-void PrintOperation::set_show_progress(bool show_progress)
-{
-gtk_print_operation_set_show_progress(gobj(), static_cast<int>(show_progress)); 
-}
-
-void PrintOperation::set_allow_async(bool allow_async)
-{
-gtk_print_operation_set_allow_async(gobj(), static_cast<int>(allow_async)); 
-}
-
-void PrintOperation::set_custom_tab_label(const Glib::ustring& label)
-{
-gtk_print_operation_set_custom_tab_label(gobj(), label.c_str()); 
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-PrintOperationResult PrintOperation::run(PrintOperationAction action, Window& parent)
-#else
-PrintOperationResult PrintOperation::run(PrintOperationAction action, Window& parent, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  PrintOperationResult retvalue = (PrintOperationResult)gtk_print_operation_run(gobj(), ((GtkPrintOperationAction)(action)), (parent).gobj(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-PrintStatus PrintOperation::get_status() const
-{
-  return (PrintStatus)gtk_print_operation_get_status(const_cast<GtkPrintOperation*>(gobj()));
-}
-
-Glib::ustring PrintOperation::get_status_string() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_operation_get_status_string(const_cast<GtkPrintOperation*>(gobj())));
-}
-
-void PrintOperation::cancel()
-{
-gtk_print_operation_cancel(gobj()); 
-}
-
-bool PrintOperation::is_finished() const
-{
-  return gtk_print_operation_is_finished(const_cast<GtkPrintOperation*>(gobj()));
-}
-
-
-Glib::SignalProxy1< void,PrintOperationResult > PrintOperation::signal_done()
-{
-  return Glib::SignalProxy1< void,PrintOperationResult >(this, &PrintOperation_signal_done_info);
-}
-
-
-Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& > PrintOperation::signal_begin_print()
-{
-  return Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& >(this, &PrintOperation_signal_begin_print_info);
-}
-
-
-Glib::SignalProxy1< bool,const Glib::RefPtr<PrintContext>& > PrintOperation::signal_paginate()
-{
-  return Glib::SignalProxy1< bool,const Glib::RefPtr<PrintContext>& >(this, &PrintOperation_signal_paginate_info);
-}
-
-
-Glib::SignalProxy3< void,const Glib::RefPtr<PrintContext>&,int,const Glib::RefPtr<PageSetup>& > PrintOperation::signal_request_page_setup()
-{
-  return Glib::SignalProxy3< void,const Glib::RefPtr<PrintContext>&,int,const Glib::RefPtr<PageSetup>& >(this, &PrintOperation_signal_request_page_setup_info);
-}
-
-
-Glib::SignalProxy2< void,const Glib::RefPtr<PrintContext>&,int > PrintOperation::signal_draw_page()
-{
-  return Glib::SignalProxy2< void,const Glib::RefPtr<PrintContext>&,int >(this, &PrintOperation_signal_draw_page_info);
-}
-
-
-Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& > PrintOperation::signal_end_print()
-{
-  return Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& >(this, &PrintOperation_signal_end_print_info);
-}
-
-
-Glib::SignalProxy0< void > PrintOperation::signal_status_changed()
-{
-  return Glib::SignalProxy0< void >(this, &PrintOperation_signal_status_changed_info);
-}
-
-
-Glib::SignalProxy0< Widget* > PrintOperation::signal_create_custom_widget()
-{
-  return Glib::SignalProxy0< Widget* >(this, &PrintOperation_signal_create_custom_widget_info);
-}
-
-
-Glib::SignalProxy1< void,Widget* > PrintOperation::signal_custom_widget_apply()
-{
-  return Glib::SignalProxy1< void,Widget* >(this, &PrintOperation_signal_custom_widget_apply_info);
-}
-
-
-Glib::SignalProxy3< bool,const Glib::RefPtr<PrintOperationPreview>&,const Glib::RefPtr<PrintContext>&,Window* > PrintOperation::signal_preview()
-{
-  return Glib::SignalProxy3< bool,const Glib::RefPtr<PrintOperationPreview>&,const Glib::RefPtr<PrintContext>&,Window* >(this, &PrintOperation_signal_preview_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy< Glib::RefPtr<PageSetup> > PrintOperation::property_default_page_setup() 
-{
-  return Glib::PropertyProxy< Glib::RefPtr<PageSetup> >(this, "default-page-setup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PageSetup> > PrintOperation::property_default_page_setup() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PageSetup> >(this, "default-page-setup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy< Glib::RefPtr<PrintSettings> > PrintOperation::property_print_settings() 
-{
-  return Glib::PropertyProxy< Glib::RefPtr<PrintSettings> >(this, "print-settings");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PrintSettings> > PrintOperation::property_print_settings() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PrintSettings> >(this, "print-settings");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> PrintOperation::property_job_name() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "job-name");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> PrintOperation::property_job_name() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "job-name");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> PrintOperation::property_n_pages() 
-{
-  return Glib::PropertyProxy<int>(this, "n-pages");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> PrintOperation::property_n_pages() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "n-pages");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> PrintOperation::property_current_page() 
-{
-  return Glib::PropertyProxy<int>(this, "current-page");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> PrintOperation::property_current_page() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "current-page");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> PrintOperation::property_use_full_page() 
-{
-  return Glib::PropertyProxy<bool>(this, "use-full-page");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> PrintOperation::property_use_full_page() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "use-full-page");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Unit> PrintOperation::property_unit() 
-{
-  return Glib::PropertyProxy<Unit>(this, "unit");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Unit> PrintOperation::property_unit() const
-{
-  return Glib::PropertyProxy_ReadOnly<Unit>(this, "unit");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> PrintOperation::property_show_progress() 
-{
-  return Glib::PropertyProxy<bool>(this, "show-progress");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> PrintOperation::property_show_progress() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-progress");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> PrintOperation::property_allow_async() 
-{
-  return Glib::PropertyProxy<bool>(this, "allow-async");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> PrintOperation::property_allow_async() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "allow-async");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<std::string> PrintOperation::property_export_filename() 
-{
-  return Glib::PropertyProxy<std::string>(this, "export-filename");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<std::string> PrintOperation::property_export_filename() const
-{
-  return Glib::PropertyProxy_ReadOnly<std::string>(this, "export-filename");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<PrintStatus> PrintOperation::property_status() const
-{
-  return Glib::PropertyProxy_ReadOnly<PrintStatus>(this, "status");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> PrintOperation::property_status_string() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "status-string");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> PrintOperation::property_custom_tab_label() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "custom-tab-label");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> PrintOperation::property_custom_tab_label() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "custom-tab-label");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Gtk::PrintOperation::on_done(PrintOperationResult result)
-{
-  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->done)
-    (*base->done)(gobj(),((GtkPrintOperationResult)(result)));
-}
-void Gtk::PrintOperation::on_begin_print(const Glib::RefPtr<PrintContext>& context)
-{
-  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->begin_print)
-    (*base->begin_print)(gobj(),Glib::unwrap(context));
-}
-bool Gtk::PrintOperation::on_paginate(const Glib::RefPtr<PrintContext>& context)
-{
-  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->paginate)
-    return (*base->paginate)(gobj(),Glib::unwrap(context));
-
-  typedef bool RType;
-  return RType();
-}
-void Gtk::PrintOperation::on_request_page_setup(const Glib::RefPtr<PrintContext>& context, int page_no, const Glib::RefPtr<PageSetup>& setup)
-{
-  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_page_setup)
-    (*base->request_page_setup)(gobj(),Glib::unwrap(context),page_no,Glib::unwrap(setup));
-}
-void Gtk::PrintOperation::on_draw_page(const Glib::RefPtr<PrintContext>& context, int page_nr)
-{
-  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_page)
-    (*base->draw_page)(gobj(),Glib::unwrap(context),page_nr);
-}
-void Gtk::PrintOperation::on_end_print(const Glib::RefPtr<PrintContext>& context)
-{
-  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->end_print)
-    (*base->end_print)(gobj(),Glib::unwrap(context));
-}
-void Gtk::PrintOperation::on_status_changed()
-{
-  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->status_changed)
-    (*base->status_changed)(gobj());
-}
-Widget* Gtk::PrintOperation::on_create_custom_widget()
-{
-  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->create_custom_widget)
-    return Glib::wrap((*base->create_custom_widget)(gobj()));
-
-  typedef Widget* RType;
-  return RType();
-}
-void Gtk::PrintOperation::on_custom_widget_apply(Widget* widget)
-{
-  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->custom_widget_apply)
-    (*base->custom_widget_apply)(gobj(),(GtkWidget*)Glib::unwrap(widget));
-}
-bool Gtk::PrintOperation::on_preview(const Glib::RefPtr<PrintOperationPreview>& preview, const Glib::RefPtr<PrintContext>& context, Window* parent)
-{
-  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->preview)
-    return (*base->preview)(gobj(),(preview)->gobj(),Glib::unwrap(context),Glib::unwrap(parent));
-
-  typedef bool RType;
-  return RType();
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printoperation.h b/libs/gtkmm2/gtk/gtkmm/printoperation.h
deleted file mode 100644
index 54888c775d..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printoperation.h
+++ /dev/null
@@ -1,749 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTOPERATION_H
-#define _GTKMM_PRINTOPERATION_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/object.h>
-
-#include <gtkmm/pagesetup.h>
-#include <gtkmm/printcontext.h>
-#include <gtkmm/printoperationpreview.h>
-#include <gtkmm/printsettings.h>
-#include <gtkmm/window.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPrintOperation GtkPrintOperation;
-typedef struct _GtkPrintOperationClass GtkPrintOperationClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PrintOperation_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- */
-enum PrintStatus
-{
-  PRINT_STATUS_INITIAL,
-  PRINT_STATUS_PREPARING,
-  PRINT_STATUS_GENERATING_DATA,
-  PRINT_STATUS_SENDING_DATA,
-  PRINT_STATUS_PENDING,
-  PRINT_STATUS_PENDING_ISSUE,
-  PRINT_STATUS_PRINTING,
-  PRINT_STATUS_FINISHED,
-  PRINT_STATUS_FINISHED_ABORTED
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintStatus> : public Glib::Value_Enum<Gtk::PrintStatus>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-/**
- * @ingroup gtkmmEnums
- */
-enum PrintOperationResult
-{
-  PRINT_OPERATION_RESULT_ERROR,
-  PRINT_OPERATION_RESULT_APPLY,
-  PRINT_OPERATION_RESULT_CANCEL,
-  PRINT_OPERATION_RESULT_IN_PROGRESS
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintOperationResult> : public Glib::Value_Enum<Gtk::PrintOperationResult>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-/**
- * @ingroup gtkmmEnums
- */
-enum PrintOperationAction
-{
-  PRINT_OPERATION_ACTION_PRINT_DIALOG,
-  PRINT_OPERATION_ACTION_PRINT,
-  PRINT_OPERATION_ACTION_PREVIEW,
-  PRINT_OPERATION_ACTION_EXPORT
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintOperationAction> : public Glib::Value_Enum<Gtk::PrintOperationAction>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-class PrintError : public Glib::Error
-{
-public:
-  enum Code
-  {
-    GENERAL,
-    INTERNAL_ERROR,
-    NOMEM
-  };
-
-  PrintError(Code error_code, const Glib::ustring& error_message);
-  explicit PrintError(GError* gobject);
-  Code code() const;
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  friend void wrap_init(); // uses throw_func()
-#endif
-};
-
-} // namespace Gtk
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintError::Code> : public Glib::Value_Enum<Gtk::PrintError::Code>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** @defgroup Printing Printing
- */
-
-/** PrintOperation is the high-level, portable printing API. It looks a bit different than other 
- * GTK+ dialogs such as the FileChooser, since some platforms don't expose enough infrastructure 
- * to implement a good print dialog. On such platforms, PrintOperation uses the native print 
- * dialog. On platforms which do not provide a native print dialog, GTK+ uses its own, see PrintUnixDialog.
- *
- * The typical way to use the high-level printing API is to create a PrintOperation object 
- * when the user chooses to print. Then you set some properties on it,such as the page size, any PrintSettings 
- * from previous print operations, the number of  pages, the current page, etc.
- *
- * Then you start the print operation by calling run(). It will then show a dialog to 
- * let the user select a printer and options. When the user finishes the dialog various signals will be 
- * emitted by the PrintOperation for you to handle, the main one being draw_page. You should then 
- * render the page on the provided PrintContext using Cairo.
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PrintOperation :
-  public Glib::Object,
-  public PrintOperationPreview
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef PrintOperation CppObjectType;
-  typedef PrintOperation_Class CppClassType;
-  typedef GtkPrintOperation BaseObjectType;
-  typedef GtkPrintOperationClass BaseClassType;
-
-private:  friend class PrintOperation_Class;
-  static CppClassType printoperation_class_;
-
-private:
-  // noncopyable
-  PrintOperation(const PrintOperation&);
-  PrintOperation& operator=(const PrintOperation&);
-
-protected:
-  explicit PrintOperation(const Glib::ConstructParams& construct_params);
-  explicit PrintOperation(GtkPrintOperation* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~PrintOperation();
-
-#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 GObject.
-  GtkPrintOperation*       gobj()       { return reinterpret_cast<GtkPrintOperation*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkPrintOperation* gobj() const { return reinterpret_cast<GtkPrintOperation*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkPrintOperation* gobj_copy();
-
-private:
-
-  
-protected:
-  PrintOperation();
-
-public:
-  
-  static Glib::RefPtr<PrintOperation> create();
-
-
-  void set_default_page_setup(const Glib::RefPtr<PageSetup>& default_page_setup);
-  
-  Glib::RefPtr<PageSetup> get_default_page_setup() const;
-
-  
-  void set_print_settings(const Glib::RefPtr<PrintSettings>& print_settings);
-  
-  Glib::RefPtr<PrintSettings> get_print_settings() const;
-
-  
-  void set_job_name(const Glib::ustring& job_name);
-  
-  void set_n_pages(int n_pages);
-  
-  void set_current_page(int current_page);
-  
-  void set_use_full_page(bool use_full_page = true);
-  
-  void set_unit(Unit unit);
-  
-  void set_export_filename(const std::string& filename);
-  
-  void set_track_print_status(bool track_status = true);
-  
-  void set_show_progress (bool show_progress = true);
-  
-  void set_allow_async(bool allow_async = true);
-  
-  void set_custom_tab_label(const Glib::ustring& label);
-
-   
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  PrintOperationResult run(PrintOperationAction action = PRINT_OPERATION_ACTION_PRINT_DIALOG);
-  #else
-  PrintOperationResult run(PrintOperationAction action, std::auto_ptr<Glib::Error>& error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  PrintOperationResult run(PrintOperationAction action, Window& parent);
-#else
-  PrintOperationResult run(PrintOperationAction action, Window& parent, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-  PrintStatus get_status() const;
-  
-  Glib::ustring get_status_string() const;
-  
-  void cancel();
-  
-  bool is_finished() const;
-
-  
-  //TODO: point out in the docs that the PrintOperationResult enum may also indicate
-  // that an error occurred, and in that case it is up to him to handle it.
-  
-/**
-   * @par Prototype:
-   * <tt>void %done(PrintOperationResult result)</tt>
-   */
-
-  Glib::SignalProxy1< void,PrintOperationResult > signal_done();
-
-
-/**
-   * @par Prototype:
-   * <tt>void %begin_print(const Glib::RefPtr<PrintContext>& context)</tt>
-   */
-
-  Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& > signal_begin_print();
-
-  
-/**
-   * @par Prototype:
-   * <tt>bool %paginate(const Glib::RefPtr<PrintContext>& context)</tt>
-   */
-
-  Glib::SignalProxy1< bool,const Glib::RefPtr<PrintContext>& > signal_paginate();
-
-
-/**
-   * @par Prototype:
-   * <tt>void %request_page_setup(const Glib::RefPtr<PrintContext>& context, int page_no, const Glib::RefPtr<PageSetup>& setup)</tt>
-   */
-
-  Glib::SignalProxy3< void,const Glib::RefPtr<PrintContext>&,int,const Glib::RefPtr<PageSetup>& > signal_request_page_setup();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %draw_page(const Glib::RefPtr<PrintContext>& context, int page_nr)</tt>
-   */
-
-  Glib::SignalProxy2< void,const Glib::RefPtr<PrintContext>&,int > signal_draw_page();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %end_print(const Glib::RefPtr<PrintContext>& context)</tt>
-   */
-
-  Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& > signal_end_print();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %status_changed()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_status_changed();
-
-
-/**
-   * @par Prototype:
-   * <tt>Widget* %create_custom_widget()</tt>
-   */
-
-  Glib::SignalProxy0< Widget* > signal_create_custom_widget();
-
-
-/**
-   * @par Prototype:
-   * <tt>void %custom_widget_apply(Widget* widget)</tt>
-   */
-
-  Glib::SignalProxy1< void,Widget* > signal_custom_widget_apply();
-
-
-  //TODO: This is causing crashes:
-  
-/**
-   * @par Prototype:
-   * <tt>bool %preview(const Glib::RefPtr<PrintOperationPreview>& preview, const Glib::RefPtr<PrintContext>& context, Window* parent)</tt>
-   */
-
-  Glib::SignalProxy3< bool,const Glib::RefPtr<PrintOperationPreview>&,const Glib::RefPtr<PrintContext>&,Window* > signal_preview();
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPageSetup used by default.
-   *
-   * 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<PageSetup> > property_default_page_setup() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPageSetup used by default.
-   *
-   * 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<PageSetup> > property_default_page_setup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPrintSettings used for initializing the dialog.
-   *
-   * 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<PrintSettings> > property_print_settings() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPrintSettings used for initializing the dialog.
-   *
-   * 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<PrintSettings> > property_print_settings() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A string used for identifying the print job.
-   *
-   * 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_job_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** A string used for identifying the print job.
-   *
-   * 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_job_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of pages in the document.
-   *
-   * 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_n_pages() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of pages in the document.
-   *
-   * 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_n_pages() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current page in the document.
-   *
-   * 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_current_page() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current page in the document.
-   *
-   * 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_current_page() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if the the origin of the context should be at the corner of the page and not the corner of the imageable area.
-   *
-   * 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_use_full_page() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if the the origin of the context should be at the corner of the page and not the corner of the imageable area.
-   *
-   * 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_use_full_page() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The unit in which distances can be measured in the context.
-   *
-   * 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<Unit> property_unit() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The unit in which distances can be measured in the context.
-   *
-   * 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<Unit> property_unit() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if a progress dialog is shown while printing.
-   *
-   * 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_show_progress() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if a progress dialog is shown while printing.
-   *
-   * 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_show_progress() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if print process may run asynchronous.
-   *
-   * 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_allow_async() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if print process may run asynchronous.
-   *
-   * 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_allow_async() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Export filename.
-   *
-   * 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<std::string> property_export_filename() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Export filename.
-   *
-   * 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<std::string> property_export_filename() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The status of the print operation.
-   *
-   * 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<PrintStatus> property_status() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A human-readable description of the status.
-   *
-   * 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_status_string() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Label for the tab containing custom widgets.
-   *
-   * 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_custom_tab_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Label for the tab containing custom widgets.
-   *
-   * 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_custom_tab_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual void on_done(PrintOperationResult result);
-  virtual void on_begin_print(const Glib::RefPtr<PrintContext>& context);
-  virtual bool on_paginate(const Glib::RefPtr<PrintContext>& context);
-  virtual void on_request_page_setup(const Glib::RefPtr<PrintContext>& context, int page_no, const Glib::RefPtr<PageSetup>& setup);
-  virtual void on_draw_page(const Glib::RefPtr<PrintContext>& context, int page_nr);
-  virtual void on_end_print(const Glib::RefPtr<PrintContext>& context);
-  virtual void on_status_changed();
-  virtual Widget* on_create_custom_widget();
-  virtual void on_custom_widget_apply(Widget* widget);
-  virtual bool on_preview(const Glib::RefPtr<PrintOperationPreview>& preview, const Glib::RefPtr<PrintContext>& context, Window* parent);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-  //TODO: Make these static members of a class instead of non-class functions?
-
-  //Note: gtk_run_page_setup_dialog() can take a null page_setup object, but the application should always 
-  //store and reuse a page_setup object, so I see no need to provide an overload for that. murrayc.
-  //TODO: The parent parameter may also be null, so maybe we should add an overload for that.
-
-  /** Runs a page setup dialog, letting the user modify the values from page_setup. 
-   * If the user cancels the dialog, the returned PageSetup is identical to that passed in @a page_setup, 
-   * otherwise it contains the modifications done in the dialog.
-   * 
-   * Note that this function may use a recursive mainloop to show the page setup dialog. 
-   * See run_page_setup_dialog_async() if this is a problem.
-   *
-   * @param parent Transient parent.
-   * @param page_setup An existing GtkPageSetup.
-   * @param settings Print settings.
-   * @result A new PageSetup object.
-   *
-   * @since 2.10
-   */
-  Glib::RefPtr<PageSetup> run_page_setup_dialog(Window& parent,
-                                                const Glib::RefPtr<const PageSetup>& page_setup,
-                                                const Glib::RefPtr<const PrintSettings>& print_settings);
-
-  /** For example, 
-   * void on_setup_done(const Glib::RefPtr<PageSetup>& page_setup);
-   */
-  typedef sigc::slot< void, const Glib::RefPtr<PageSetup>& > SlotPrintSetupDone;
-
-  /** Runs a page setup dialog, letting the user modify the values from page_setup.
-   *
-   * In contrast to run_page_setup_dialog(), this function returns after showing the 
-   * page setup dialog on platforms that support this, and calls the @a slot from a 
-   * signal handler for the ::response signal of the dialog.
-   *
-   * @param parent Transient parent.
-   * @param page_setup An existing GtkPageSetup.
-   * @param settings Print settings.
-   * @result A new PageSetup object.
-   * @param slot
-   *
-   * @since 2.10
-   */
-  void run_page_setup_dialog_async(Window& parent,
-                                   const Glib::RefPtr<const PageSetup>& page_setup,
-                                   const Glib::RefPtr<const PrintSettings>& print_settings,
-                                   const SlotPrintSetupDone& slot);
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PrintOperation
-   * @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<Gtk::PrintOperation> wrap(GtkPrintOperation* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_PRINTOPERATION_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printoperationpreview.cc b/libs/gtkmm2/gtk/gtkmm/printoperationpreview.cc
deleted file mode 100644
index 222759c8ae..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printoperationpreview.cc
+++ /dev/null
@@ -1,489 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/printoperationpreview.h>
-#include <gtkmm/private/printoperationpreview_p.h>
-
-// -*- c++ -*-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprintoperationpreview.h>
-
-namespace
-{
-
-
-static void PrintOperationPreview_signal_ready_callback(GtkPrintOperationPreview* self, GtkPrintContext* p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintContext>& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperationPreview_signal_ready_info =
-{
-  "ready",
-  (GCallback) &PrintOperationPreview_signal_ready_callback,
-  (GCallback) &PrintOperationPreview_signal_ready_callback
-};
-
-
-static void PrintOperationPreview_signal_got_page_size_callback(GtkPrintOperationPreview* self, GtkPrintContext* p0,GtkPageSetup* p1,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,const Glib::RefPtr<PrintContext>&,const Glib::RefPtr<PageSetup>& > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
-, Glib::wrap(p1, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo PrintOperationPreview_signal_got_page_size_info =
-{
-  "got_page_size",
-  (GCallback) &PrintOperationPreview_signal_got_page_size_callback,
-  (GCallback) &PrintOperationPreview_signal_got_page_size_callback
-};
-
-
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::PrintOperationPreview> wrap(GtkPrintOperationPreview* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::PrintOperationPreview>( dynamic_cast<Gtk::PrintOperationPreview*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} // namespace Glib
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Interface_Class& PrintOperationPreview_Class::init()
-{
-  if(!gtype_) // create the GType if necessary
-  {
-    // Glib::Interface_Class has to know the interface init function
-    // in order to add interfaces to implementing types.
-    class_init_func_ = &PrintOperationPreview_Class::iface_init_function;
-
-    // We can not derive from another interface, and it is not necessary anyway.
-    gtype_ = gtk_print_operation_preview_get_type();
-  }
-
-  return *this;
-}
-
-void PrintOperationPreview_Class::iface_init_function(void* g_iface, void*)
-{
-  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
-
-  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
-  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
-  g_assert(klass != 0); 
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-  klass->render_page = &render_page_vfunc_callback;
-  klass->end_preview = &end_preview_vfunc_callback;
-  klass->is_selected = &is_selected_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->ready = &ready_callback;
-  klass->got_page_size = &got_page_size_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-void PrintOperationPreview_Class::render_page_vfunc_callback(GtkPrintOperationPreview* self, gint page_nr)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->render_page_vfunc(page_nr
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->render_page)
-      (*base->render_page)(self, page_nr);
-  }
-}
-void PrintOperationPreview_Class::end_preview_vfunc_callback(GtkPrintOperationPreview* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->end_preview_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->end_preview)
-      (*base->end_preview)(self);
-  }
-}
-gboolean PrintOperationPreview_Class::is_selected_vfunc_callback(GtkPrintOperationPreview* self, gint page_nr)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      return static_cast<int>(obj->is_selected_vfunc(page_nr
-));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->is_selected)
-      return (*base->is_selected)(self, page_nr);
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void PrintOperationPreview_Class::ready_callback(GtkPrintOperationPreview* self, GtkPrintContext* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_ready(Glib::wrap(p0, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->ready)
-      (*base->ready)(self, p0);
-  }
-}
-void PrintOperationPreview_Class::got_page_size_callback(GtkPrintOperationPreview* self, GtkPrintContext* p0, GtkPageSetup* p1)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_got_page_size(Glib::wrap(p0, true)
-, Glib::wrap(p1, true)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->got_page_size)
-      (*base->got_page_size)(self, p0, p1);
-  }
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PrintOperationPreview_Class::wrap_new(GObject* object)
-{
-  return new PrintOperationPreview((GtkPrintOperationPreview*)(object));
-}
-
-
-/* The implementation: */
-
-PrintOperationPreview::PrintOperationPreview()
-:
-  Glib::Interface(printoperationpreview_class_.init())
-{}
-
-PrintOperationPreview::PrintOperationPreview(GtkPrintOperationPreview* castitem)
-:
-  Glib::Interface((GObject*)(castitem))
-{}
-
-PrintOperationPreview::~PrintOperationPreview()
-{}
-
-// static
-void PrintOperationPreview::add_interface(GType gtype_implementer)
-{
-  printoperationpreview_class_.init().add_interface(gtype_implementer);
-}
-
-PrintOperationPreview::CppClassType PrintOperationPreview::printoperationpreview_class_; // initialize static member
-
-GType PrintOperationPreview::get_type()
-{
-  return printoperationpreview_class_.init().get_type();
-}
-
-GType PrintOperationPreview::get_base_type()
-{
-  return gtk_print_operation_preview_get_type();
-}
-
-
-void PrintOperationPreview::render_page(int page_nr)
-{
-gtk_print_operation_preview_render_page(gobj(), page_nr); 
-}
-
-void PrintOperationPreview::end_preview()
-{
-gtk_print_operation_preview_end_preview(gobj()); 
-}
-
-bool PrintOperationPreview::is_selected(int page_nr) const
-{
-  return gtk_print_operation_preview_is_selected(const_cast<GtkPrintOperationPreview*>(gobj()), page_nr);
-}
-
-
-Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& > PrintOperationPreview::signal_ready()
-{
-  return Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& >(this, &PrintOperationPreview_signal_ready_info);
-}
-
-
-Glib::SignalProxy2< void,const Glib::RefPtr<PrintContext>&,const Glib::RefPtr<PageSetup>& > PrintOperationPreview::signal_got_page_size()
-{
-  return Glib::SignalProxy2< void,const Glib::RefPtr<PrintContext>&,const Glib::RefPtr<PageSetup>& >(this, &PrintOperationPreview_signal_got_page_size_info);
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Gtk::PrintOperationPreview::on_ready(const Glib::RefPtr<PrintContext>& context)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->ready)
-    (*base->ready)(gobj(),Glib::unwrap(context));
-}
-void Gtk::PrintOperationPreview::on_got_page_size(const Glib::RefPtr<PrintContext>& context, const Glib::RefPtr<PageSetup>& page_setup)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->got_page_size)
-    (*base->got_page_size)(gobj(),Glib::unwrap(context),Glib::unwrap(page_setup));
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-void Gtk::PrintOperationPreview::render_page_vfunc(int page_nr) 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->render_page)
-    (*base->render_page)(gobj(),page_nr);
-}
-void Gtk::PrintOperationPreview::end_preview_vfunc() 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->end_preview)
-    (*base->end_preview)(gobj());
-}
-bool Gtk::PrintOperationPreview::is_selected_vfunc(int page_nr) const
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->is_selected)
-    return (*base->is_selected)(const_cast<GtkPrintOperationPreview*>(gobj()),page_nr);
-
-  typedef bool RType;
-  return RType();
-}
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printoperationpreview.h b/libs/gtkmm2/gtk/gtkmm/printoperationpreview.h
deleted file mode 100644
index 596a9a8010..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printoperationpreview.h
+++ /dev/null
@@ -1,169 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTOPERATIONPREVIEW_H
-#define _GTKMM_PRINTOPERATIONPREVIEW_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprintoperationpreview.h>
-
-#include <glibmm/interface.h>
-
-#include <gtkmm/pagesetup.h>
-#include <gtkmm/printcontext.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPrintOperationPreview GtkPrintOperationPreview;
-typedef struct _GtkPrintOperationPreviewClass GtkPrintOperationPreviewClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PrintOperationPreview_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** TODO:
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PrintOperationPreview : public Glib::Interface
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef PrintOperationPreview CppObjectType;
-  typedef PrintOperationPreview_Class CppClassType;
-  typedef GtkPrintOperationPreview BaseObjectType;
-  typedef GtkPrintOperationPreviewIface BaseClassType;
-
-private:
-  friend class PrintOperationPreview_Class;
-  static CppClassType printoperationpreview_class_;
-
-  // noncopyable
-  PrintOperationPreview(const PrintOperationPreview&);
-  PrintOperationPreview& operator=(const PrintOperationPreview&);
-
-protected:
-  PrintOperationPreview(); // you must derive from this class
-  explicit PrintOperationPreview(GtkPrintOperationPreview* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~PrintOperationPreview();
-
-  static void add_interface(GType gtype_implementer);
-
-#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 GObject.
-  GtkPrintOperationPreview*       gobj()       { return reinterpret_cast<GtkPrintOperationPreview*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.  
-  const GtkPrintOperationPreview* gobj() const { return reinterpret_cast<GtkPrintOperationPreview*>(gobject_); }
-
-private:
-
-public:
-
-  
-  void render_page(int page_nr);
-  
-  void end_preview();
-  
-  bool is_selected(int page_nr) const;
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void render_page_vfunc(int page_nr);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void end_preview_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool is_selected_vfunc(int page_nr) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-/**
-   * @par Prototype:
-   * <tt>void %ready(const Glib::RefPtr<PrintContext>& context)</tt>
-   */
-
-  Glib::SignalProxy1< void,const Glib::RefPtr<PrintContext>& > signal_ready();
-
-  
-/**
-   * @par Prototype:
-   * <tt>void %got_page_size(const Glib::RefPtr<PrintContext>& context, const Glib::RefPtr<PageSetup>& page_setup)</tt>
-   */
-
-  Glib::SignalProxy2< void,const Glib::RefPtr<PrintContext>&,const Glib::RefPtr<PageSetup>& > signal_got_page_size();
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual void on_ready(const Glib::RefPtr<PrintContext>& context);
-  virtual void on_got_page_size(const Glib::RefPtr<PrintContext>& context, const Glib::RefPtr<PageSetup>& page_setup);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PrintOperationPreview
-   * @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<Gtk::PrintOperationPreview> wrap(GtkPrintOperationPreview* object, bool take_copy = false);
-
-} // namespace Glib
-
-
-#endif /* _GTKMM_PRINTOPERATIONPREVIEW_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printsettings.cc b/libs/gtkmm2/gtk/gtkmm/printsettings.cc
deleted file mode 100644
index a802ebbef6..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printsettings.cc
+++ /dev/null
@@ -1,580 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/printsettings.h>
-#include <gtkmm/private/printsettings_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprintsettings.h>
-#include <gtk/gtktypebuiltins.h>
-
-#include <vector>
-
-#include <glib/gmem.h>
-
-namespace // anonymous
-{
-
-static void proxy_foreach_callback(const gchar* key, const gchar* value, void* data)
-{
-  typedef Gtk::PrintSettings::SlotForeach SlotType;
-  SlotType& slot = *static_cast<SlotType*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    Glib::ustring k(key);
-    Glib::ustring v(value);
-    slot(k, v);
-    //slot(Glib::ustring(key), Glib::ustring(value)); // TODO: this won't work
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-} // anonymous namespace
-
-namespace Gtk
-{
-
-//Initialize static members:
-const Glib::ustring PrintSettings::Keys::PRINTER = GTK_PRINT_SETTINGS_PRINTER;
-const Glib::ustring PrintSettings::Keys::ORIENTATION = GTK_PRINT_SETTINGS_ORIENTATION;
-const Glib::ustring PrintSettings::Keys::PAPER_FORMAT = GTK_PRINT_SETTINGS_PAPER_FORMAT;
-const Glib::ustring PrintSettings::Keys::PAPER_WIDTH = GTK_PRINT_SETTINGS_PAPER_WIDTH;
-const Glib::ustring PrintSettings::Keys::PAPER_HEIGHT = GTK_PRINT_SETTINGS_PAPER_HEIGHT;
-const Glib::ustring PrintSettings::Keys::NUM_COPIES = GTK_PRINT_SETTINGS_N_COPIES;
-const Glib::ustring PrintSettings::Keys::DEFAULT_SOURCE = GTK_PRINT_SETTINGS_DEFAULT_SOURCE;
-const Glib::ustring PrintSettings::Keys::QUALITY = GTK_PRINT_SETTINGS_QUALITY;
-const Glib::ustring PrintSettings::Keys::RESOLUTION = GTK_PRINT_SETTINGS_RESOLUTION;
-const Glib::ustring PrintSettings::Keys::USE_COLOR = GTK_PRINT_SETTINGS_USE_COLOR;
-const Glib::ustring PrintSettings::Keys::DUPLEX = GTK_PRINT_SETTINGS_DUPLEX;
-const Glib::ustring PrintSettings::Keys::COLLATE = GTK_PRINT_SETTINGS_COLLATE;
-const Glib::ustring PrintSettings::Keys::REVERSE = GTK_PRINT_SETTINGS_REVERSE;
-const Glib::ustring PrintSettings::Keys::MEDIA_TYPE = GTK_PRINT_SETTINGS_MEDIA_TYPE;
-const Glib::ustring PrintSettings::Keys::DITHER = GTK_PRINT_SETTINGS_DITHER;
-const Glib::ustring PrintSettings::Keys::SCALE = GTK_PRINT_SETTINGS_SCALE;
-const Glib::ustring PrintSettings::Keys::PRINT_PAGES = GTK_PRINT_SETTINGS_PRINT_PAGES;
-const Glib::ustring PrintSettings::Keys::PAGE_RANGES = GTK_PRINT_SETTINGS_PAGE_RANGES;
-const Glib::ustring PrintSettings::Keys::PAGE_SET = GTK_PRINT_SETTINGS_PAGE_SET;
-const Glib::ustring PrintSettings::Keys::FINISHINGS = GTK_PRINT_SETTINGS_FINISHINGS;
-const Glib::ustring PrintSettings::Keys::NUMBER_UP = GTK_PRINT_SETTINGS_NUMBER_UP;
-const Glib::ustring PrintSettings::Keys::OUTPUT_BIN = GTK_PRINT_SETTINGS_OUTPUT_BIN;
-
-const Glib::ustring PrintSettings::Keys::OUTPUT_FILE_FORMAT = GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT;
-const Glib::ustring PrintSettings::Keys::OUTPUT_URI = GTK_PRINT_SETTINGS_OUTPUT_URI;
-
-const Glib::ustring PrintSettings::Keys::WIN32_DRIVER_VERSION = GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION;
-const Glib::ustring PrintSettings::Keys::WIN32_DRIVER_EXTRA = GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA;
-
-
-void PrintSettings::setting_foreach(const SlotForeach& slot)
-{
-  SlotForeach slot_copy(slot);
-  gtk_print_settings_foreach(const_cast<GtkPrintSettings*>(gobj()), &proxy_foreach_callback, &slot_copy);
-}
-
-PrintSettings::PageRange::PageRange()
-:
-  start(0),
-  end(0)
-{}
-
-PrintSettings::PageRange::PageRange(int start_, int end_)
-:
-  start(start_),
-  end(end_)
-{}
-
-Glib::ArrayHandle<PrintSettings::PageRange> PrintSettings::get_page_ranges() const
-{
-  int num_ranges;
-  GtkPageRange* page_ranges =
-    gtk_print_settings_get_page_ranges(const_cast<GtkPrintSettings*>(gobj()), &num_ranges);
-  std::vector<PrintSettings::PageRange> v(num_ranges);
-
-  for (int i = 0; i < num_ranges; ++i)
-  {
-    v.push_back(PrintSettings::PageRange(page_ranges[i].start, page_ranges[i].end));
-  }
-
-  g_free(page_ranges);
-
-  Glib::ArrayHandle<PrintSettings::PageRange> ah(v);
-
-  return ah;
-}
-
-void PrintSettings::set_page_ranges(const Glib::ArrayHandle<PrintSettings::PageRange>& page_ranges)
-{
-  int n = page_ranges.size();
-  GtkPageRange* ranges = g_new0(GtkPageRange, n);
-  std::vector<PrintSettings::PageRange> v_ranges(page_ranges);
-
-  for (int i = 0; i < n; ++i)
-  {
-    ranges[i].start = v_ranges[i].start;
-    ranges[i].end = v_ranges[i].end;
-  }
-
-  gtk_print_settings_set_page_ranges(const_cast<GtkPrintSettings*>(gobj()), ranges, n);
-  g_free(ranges);
-}
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-// static
-GType Glib::Value<Gtk::PrintDuplex>::value_type()
-{
-  return gtk_print_duplex_get_type();
-}
-
-// static
-GType Glib::Value<Gtk::PrintQuality>::value_type()
-{
-  return gtk_print_quality_get_type();
-}
-
-// static
-GType Glib::Value<Gtk::PrintPages>::value_type()
-{
-  return gtk_print_pages_get_type();
-}
-
-// static
-GType Glib::Value<Gtk::PageSet>::value_type()
-{
-  return gtk_page_set_get_type();
-}
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::PrintSettings> wrap(GtkPrintSettings* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::PrintSettings>( dynamic_cast<Gtk::PrintSettings*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& PrintSettings_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_ = &PrintSettings_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(gtk_print_settings_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void PrintSettings_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PrintSettings_Class::wrap_new(GObject* object)
-{
-  return new PrintSettings((GtkPrintSettings*)object);
-}
-
-
-/* The implementation: */
-
-GtkPrintSettings* PrintSettings::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-PrintSettings::PrintSettings(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-PrintSettings::PrintSettings(GtkPrintSettings* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-PrintSettings::~PrintSettings()
-{}
-
-
-PrintSettings::CppClassType PrintSettings::printsettings_class_; // initialize static member
-
-GType PrintSettings::get_type()
-{
-  return printsettings_class_.init().get_type();
-}
-
-GType PrintSettings::get_base_type()
-{
-  return gtk_print_settings_get_type();
-}
-
-
-PrintSettings::PrintSettings()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(printsettings_class_.init()))
-{
-  }
-
-Glib::RefPtr<PrintSettings> PrintSettings::create()
-{
-  return Glib::RefPtr<PrintSettings>( new PrintSettings() );
-}
-bool PrintSettings::has_key(const Glib::ustring& key) const
-{
-  return gtk_print_settings_has_key(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
-}
-
-Glib::ustring PrintSettings::get(const Glib::ustring& key) const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get(const_cast<GtkPrintSettings*>(gobj()), key.c_str()));
-}
-
-void PrintSettings::set(const Glib::ustring& key, const Glib::ustring& value)
-{
-gtk_print_settings_set(gobj(), key.c_str(), value.c_str()); 
-}
-
-void PrintSettings::unset(const Glib::ustring& key)
-{
-gtk_print_settings_unset(gobj(), key.c_str()); 
-}
-
-bool PrintSettings::get_bool(const Glib::ustring& key) const
-{
-  return gtk_print_settings_get_bool(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
-}
-
-void PrintSettings::set_bool(const Glib::ustring& key, bool value)
-{
-gtk_print_settings_set_bool(gobj(), key.c_str(), static_cast<int>(value)); 
-}
-
-double PrintSettings::get_double(const Glib::ustring& key) const
-{
-  return gtk_print_settings_get_double(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
-}
-
-double PrintSettings::get_double_with_default(const Glib::ustring& key, double def) const
-{
-  return gtk_print_settings_get_double_with_default(const_cast<GtkPrintSettings*>(gobj()), key.c_str(), def);
-}
-
-void PrintSettings::set_double(const Glib::ustring& key, double value)
-{
-gtk_print_settings_set_double(gobj(), key.c_str(), value); 
-}
-
-double PrintSettings::get_length(const Glib::ustring& key, Unit unit) const
-{
-  return gtk_print_settings_get_length(const_cast<GtkPrintSettings*>(gobj()), key.c_str(), ((GtkUnit)(unit)));
-}
-
-void PrintSettings::set_length(const Glib::ustring& key, double value, Unit unit)
-{
-gtk_print_settings_set_length(gobj(), key.c_str(), value, ((GtkUnit)(unit))); 
-}
-
-int PrintSettings::get_int(const Glib::ustring& key) const
-{
-  return gtk_print_settings_get_int(const_cast<GtkPrintSettings*>(gobj()), key.c_str());
-}
-
-int PrintSettings::get_int_with_default(const Glib::ustring& key, int def) const
-{
-  return gtk_print_settings_get_int_with_default(const_cast<GtkPrintSettings*>(gobj()), key.c_str(), def);
-}
-
-void PrintSettings::set_int(const Glib::ustring& key, int value)
-{
-gtk_print_settings_set_int(gobj(), key.c_str(), value); 
-}
-
-Glib::ustring PrintSettings::get_printer() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_printer(const_cast<GtkPrintSettings*>(gobj())));
-}
-
-void PrintSettings::set_printer(const Glib::ustring& name)
-{
-gtk_print_settings_set_printer(gobj(), name.c_str()); 
-}
-
-PageOrientation PrintSettings::get_orientation() const
-{
-  return (PageOrientation)gtk_print_settings_get_orientation(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_orientation(PageOrientation orientation)
-{
-gtk_print_settings_set_orientation(gobj(), ((GtkPageOrientation)(orientation))); 
-}
-
-PaperSize PrintSettings::get_paper_size()
-{
-  return Glib::wrap(gtk_print_settings_get_paper_size(gobj()), true);
-}
-
-const PaperSize PrintSettings::get_paper_size() const
-{
-  return const_cast<PrintSettings*>(this)->get_paper_size();
-}
-
-void PrintSettings::set_paper_size(const PaperSize& paper_size)
-{
-gtk_print_settings_set_paper_size(gobj(), const_cast<GtkPaperSize*>((paper_size).gobj())); 
-}
-
-double PrintSettings::get_paper_width(Unit unit) const
-{
-  return gtk_print_settings_get_paper_width(const_cast<GtkPrintSettings*>(gobj()), ((GtkUnit)(unit)));
-}
-
-void PrintSettings::set_paper_width(double width, Unit unit)
-{
-gtk_print_settings_set_paper_width(gobj(), width, ((GtkUnit)(unit))); 
-}
-
-double PrintSettings::get_paper_height(Unit unit) const
-{
-  return gtk_print_settings_get_paper_height(const_cast<GtkPrintSettings*>(gobj()), ((GtkUnit)(unit)));
-}
-
-void PrintSettings::set_paper_height(double height, Unit unit)
-{
-gtk_print_settings_set_paper_height(gobj(), height, ((GtkUnit)(unit))); 
-}
-
-bool PrintSettings::get_use_color() const
-{
-  return gtk_print_settings_get_use_color(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_use_color(bool use_color)
-{
-gtk_print_settings_set_use_color(gobj(), static_cast<int>(use_color)); 
-}
-
-bool PrintSettings::get_collate() const
-{
-  return gtk_print_settings_get_collate(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_collate(bool collate)
-{
-gtk_print_settings_set_collate(gobj(), static_cast<int>(collate)); 
-}
-
-bool PrintSettings::get_reverse() const
-{
-  return gtk_print_settings_get_reverse(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_reverse(bool reverse)
-{
-gtk_print_settings_set_reverse(gobj(), static_cast<int>(reverse)); 
-}
-
-PrintDuplex PrintSettings::get_duplex() const
-{
-  return (PrintDuplex)gtk_print_settings_get_duplex(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_duplex(PrintDuplex duplex)
-{
-gtk_print_settings_set_duplex(gobj(), ((GtkPrintDuplex)(duplex))); 
-}
-
-PrintQuality PrintSettings::get_quality() const
-{
-  return (PrintQuality)gtk_print_settings_get_quality(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_quality(PrintQuality quality)
-{
-gtk_print_settings_set_quality(gobj(), ((GtkPrintQuality)(quality))); 
-}
-
-int PrintSettings::get_n_copies() const
-{
-  return gtk_print_settings_get_n_copies(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_n_copies(int num_copies)
-{
-gtk_print_settings_set_n_copies(gobj(), num_copies); 
-}
-
-int PrintSettings::get_number_up() const
-{
-  return gtk_print_settings_get_number_up(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_number_up(int number_up)
-{
-gtk_print_settings_set_number_up(gobj(), number_up); 
-}
-
-int PrintSettings::get_resolution() const
-{
-  return gtk_print_settings_get_resolution(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_resolution(int resolution)
-{
-gtk_print_settings_set_resolution(gobj(), resolution); 
-}
-
-double PrintSettings::get_scale() const
-{
-  return gtk_print_settings_get_scale(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_scale(double scale)
-{
-gtk_print_settings_set_scale(gobj(), scale); 
-}
-
-PrintPages PrintSettings::get_print_pages() const
-{
-  return (PrintPages)gtk_print_settings_get_print_pages(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_print_pages(PrintPages print_pages)
-{
-gtk_print_settings_set_print_pages(gobj(), ((GtkPrintPages)(print_pages))); 
-}
-
-PageSet PrintSettings::get_page_set() const
-{
-  return (PageSet)gtk_print_settings_get_page_set(const_cast<GtkPrintSettings*>(gobj()));
-}
-
-void PrintSettings::set_page_set(PageSet page_set)
-{
-gtk_print_settings_set_page_set(gobj(), ((GtkPageSet)(page_set))); 
-}
-
-Glib::ustring PrintSettings::get_default_source() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_default_source(const_cast<GtkPrintSettings*>(gobj())));
-}
-
-void PrintSettings::set_default_source(const Glib::ustring& default_source)
-{
-gtk_print_settings_set_default_source(gobj(), default_source.c_str()); 
-}
-
-Glib::ustring PrintSettings::get_media_type() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_media_type(const_cast<GtkPrintSettings*>(gobj())));
-}
-
-void PrintSettings::set_media_type(const Glib::ustring& media_type)
-{
-gtk_print_settings_set_media_type(gobj(), media_type.c_str()); 
-}
-
-Glib::ustring PrintSettings::get_dither() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_dither(const_cast<GtkPrintSettings*>(gobj())));
-}
-
-void PrintSettings::set_dither(const Glib::ustring& dither)
-{
-gtk_print_settings_set_dither(gobj(), dither.c_str()); 
-}
-
-Glib::ustring PrintSettings::get_finishings() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_finishings(const_cast<GtkPrintSettings*>(gobj())));
-}
-
-void PrintSettings::set_finishings(const Glib::ustring& finishings)
-{
-gtk_print_settings_set_finishings(gobj(), finishings.c_str()); 
-}
-
-Glib::ustring PrintSettings::get_output_bin() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_print_settings_get_output_bin(const_cast<GtkPrintSettings*>(gobj())));
-}
-
-void PrintSettings::set_output_bin(const Glib::ustring& output_bin)
-{
-gtk_print_settings_set_output_bin(gobj(), output_bin.c_str()); 
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printsettings.h b/libs/gtkmm2/gtk/gtkmm/printsettings.h
deleted file mode 100644
index f171d88153..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printsettings.h
+++ /dev/null
@@ -1,477 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTSETTINGS_H
-#define _GTKMM_PRINTSETTINGS_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/object.h>
-#include <gtkmm/enums.h>
-#include <gtkmm/papersize.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPrintSettings GtkPrintSettings;
-typedef struct _GtkPrintSettingsClass GtkPrintSettingsClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PrintSettings_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- */
-enum PrintDuplex
-{
-  PRINT_DUPLEX_SIMPLEX,
-  PRINT_DUPLEX_HORIZONTAL,
-  PRINT_DUPLEX_VERTICAL
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintDuplex> : public Glib::Value_Enum<Gtk::PrintDuplex>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-/**
- * @ingroup gtkmmEnums
- */
-enum PrintQuality
-{
-  PRINT_QUALITY_LOW,
-  PRINT_QUALITY_NORMAL,
-  PRINT_QUALITY_HIGH,
-  PRINT_QUALITY_DRAFT
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintQuality> : public Glib::Value_Enum<Gtk::PrintQuality>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-/**
- * @ingroup gtkmmEnums
- */
-enum PrintPages
-{
-  PRINT_PAGES_ALL,
-  PRINT_PAGES_CURRENT,
-  PRINT_PAGES_RANGES
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PrintPages> : public Glib::Value_Enum<Gtk::PrintPages>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-/**
- * @ingroup gtkmmEnums
- */
-enum PageSet
-{
-  PAGE_SET_ALL,
-  PAGE_SET_EVEN,
-  PAGE_SET_ODD
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::PageSet> : public Glib::Value_Enum<Gtk::PageSet>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** A PrintSettings object represents the settings of a print dialog in a system-independent way. 
- * The main use for this object is that once you've printed you can get a settings object that 
- * represents the settings the user chose, and the next time you print you can pass that object 
- * in so that the user doesn't have to re-set all his settings.
- * 
- * It's also possible to enumerate the settings so that you can easily save the settings for the 
- * next time your app runs, or even store them in a document. The predefined keys try to use shared 
- * values as much as possible so that moving such a document between systems still works. 
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PrintSettings : public Glib::Object
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef PrintSettings CppObjectType;
-  typedef PrintSettings_Class CppClassType;
-  typedef GtkPrintSettings BaseObjectType;
-  typedef GtkPrintSettingsClass BaseClassType;
-
-private:  friend class PrintSettings_Class;
-  static CppClassType printsettings_class_;
-
-private:
-  // noncopyable
-  PrintSettings(const PrintSettings&);
-  PrintSettings& operator=(const PrintSettings&);
-
-protected:
-  explicit PrintSettings(const Glib::ConstructParams& construct_params);
-  explicit PrintSettings(GtkPrintSettings* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~PrintSettings();
-
-#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 GObject.
-  GtkPrintSettings*       gobj()       { return reinterpret_cast<GtkPrintSettings*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkPrintSettings* gobj() const { return reinterpret_cast<GtkPrintSettings*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkPrintSettings* gobj_copy();
-
-private:
-
-protected:
-  PrintSettings();
-
-public:
-  
-  static Glib::RefPtr<PrintSettings> create();
-
-
-  /** Print settings keys.
-   */
-  class Keys
-  {
-  public:
-    static const Glib::ustring PRINTER;
-    static const Glib::ustring ORIENTATION;
-    static const Glib::ustring PAPER_FORMAT;
-    static const Glib::ustring PAPER_WIDTH;
-    static const Glib::ustring PAPER_HEIGHT;
-    static const Glib::ustring NUM_COPIES;
-    static const Glib::ustring DEFAULT_SOURCE;
-    static const Glib::ustring QUALITY;
-    static const Glib::ustring RESOLUTION;
-    static const Glib::ustring USE_COLOR;
-    static const Glib::ustring DUPLEX;
-    static const Glib::ustring COLLATE;
-    static const Glib::ustring REVERSE;
-    static const Glib::ustring MEDIA_TYPE;
-    static const Glib::ustring DITHER;
-    static const Glib::ustring SCALE;
-    static const Glib::ustring PRINT_PAGES;
-    static const Glib::ustring PAGE_RANGES;
-    static const Glib::ustring PAGE_SET;
-    static const Glib::ustring FINISHINGS;
-    static const Glib::ustring NUMBER_UP;
-    static const Glib::ustring OUTPUT_BIN;
-
-    static const Glib::ustring OUTPUT_FILE_FORMAT;
-    static const Glib::ustring OUTPUT_URI;
-
-    static const Glib::ustring WIN32_DRIVER_VERSION;
-    static const Glib::ustring WIN32_DRIVER_EXTRA;
-  };
-
-  
-  //TODO: add a @see link?
-  
-  bool has_key(const Glib::ustring& key) const;
-
-  
-  Glib::ustring get(const Glib::ustring& key) const;
-
-  
-  void set(const Glib::ustring& key, const Glib::ustring& value);
-  
-  void unset(const Glib::ustring& key);
-
-  /** For example, 
-   * void on_foreach_setting(const Glib::ustring& key, const Glib::ustring& value);
-   */
-  typedef sigc::slot<void, Glib::ustring&, Glib::ustring&> SlotForeach;
-
-  /** Calls a function for each print setting.
-  * @param slot The callback to call for each print setting.
-  */
-  void setting_foreach(const SlotForeach& slot);
-
- 
-  bool get_bool(const Glib::ustring& key) const;
-  
-  void set_bool(const Glib::ustring& key, bool value = true);
-
-  
-  double get_double(const Glib::ustring& key) const;
-  
-  double get_double_with_default(const Glib::ustring& key, double def) const;
-  
-  void set_double(const Glib::ustring& key, double value);
-
-  
-  double get_length(const Glib::ustring& key, Unit unit) const;
-  
-  void set_length(const Glib::ustring& key, double value, Unit unit);
-
-  
-  int get_int(const Glib::ustring& key) const;
-  
-  int get_int_with_default(const Glib::ustring& key, int def) const;
-  
-  void set_int(const Glib::ustring& key, int value);
-
-  // helpers:
-
-  
-  Glib::ustring get_printer() const;
-  
-  void set_printer(const Glib::ustring& name);
-
-  
-  PageOrientation get_orientation() const;
-  
-  void set_orientation(PageOrientation orientation);
-
-  
-  PaperSize get_paper_size();
-  
-  const PaperSize get_paper_size() const;
-  
-  void set_paper_size(const PaperSize& paper_size);
-
-  
-  double get_paper_width(Unit unit) const;
-  
-  void set_paper_width(double width, Unit unit);
-  
-  double get_paper_height(Unit unit) const;
-  
-  void set_paper_height(double height, Unit unit);
-
-  
-  bool get_use_color() const;
-  
-  void set_use_color(bool use_color = true);
-
-  
-  bool get_collate() const;
-  
-  void set_collate(bool collate = true);
-
-  
-  bool get_reverse() const;
-  
-  void set_reverse(bool reverse = true);
-
-  
-  PrintDuplex get_duplex() const;
-  
-  void set_duplex(PrintDuplex duplex);
-
-  
-  PrintQuality get_quality() const;
-  
-  void set_quality(PrintQuality quality);
-
-  
-  int get_n_copies() const;
-  
-  void set_n_copies(int num_copies);
-
-  
-  int get_number_up() const;
-  
-  void set_number_up(int number_up);
-
-  
-  int get_resolution() const;
-  
-  void set_resolution(int resolution);
-
-  
-  double get_scale() const;
-  
-  void set_scale(double scale);
-
-  
-  PrintPages get_print_pages() const;
-  
-  void set_print_pages(PrintPages print_pages);
-
-  //TODO: What part of the C API does this correspond to?
-  class PageRange
-  {
-  public:
-    PageRange();
-    PageRange(int start, int end);
-
-    int start;
-    int end;
-  };
-
-  Glib::ArrayHandle<PageRange> get_page_ranges() const;
-  void set_page_ranges(const Glib::ArrayHandle<PageRange>& page_ranges);
-
-  
-  PageSet get_page_set() const;
-  
-  void set_page_set(PageSet page_set);
-
-  
-  Glib::ustring get_default_source() const;
-  
-  void set_default_source(const Glib::ustring& default_source);
-
-  
-  Glib::ustring get_media_type() const;
-  
-  void set_media_type(const Glib::ustring& media_type);
-
-  
-  Glib::ustring get_dither() const;
-  
-  void set_dither(const Glib::ustring& dither);
-
-  
-  Glib::ustring get_finishings() const;
-  
-  void set_finishings(const Glib::ustring& finishings);
-
-  
-  Glib::ustring get_output_bin() const;
-  
-  void set_output_bin(const Glib::ustring& output_bin);
-
-  //TODO: Properties.
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PrintSettings
-   * @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<Gtk::PrintSettings> wrap(GtkPrintSettings* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_PRINTSETTINGS_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printunixdialog.cc b/libs/gtkmm2/gtk/gtkmm/printunixdialog.cc
deleted file mode 100644
index c71eede812..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printunixdialog.cc
+++ /dev/null
@@ -1,293 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/printunixdialog.h>
-#include <gtkmm/private/printunixdialog_p.h>
-
-// -*- c++ -*-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkprintunixdialog.h>
-#include <gtkmm/label.h>
-
-namespace Gtk
-{
-
-PrintUnixDialog::PrintUnixDialog(Gtk::Window& parent, const Glib::ustring& title)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(printunixdialog_class_.init(), "title",title.c_str(), (char*) 0))
-{
-  set_transient_for(parent);
-}
-
-PrintUnixDialog::PrintUnixDialog(const Glib::ustring& title)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(printunixdialog_class_.init(), "title",title.c_str(), (char*) 0))
-{
-}
-
-void PrintUnixDialog::add_custom_tab(const Widget& child, const Glib::ustring& tab_label)
-{
-  Gtk::Label* label = Gtk::manage(new Gtk::Label(tab_label));
-  add_custom_tab(child, *label); 
-}
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::PrintUnixDialog* wrap(GtkPrintUnixDialog* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::PrintUnixDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& PrintUnixDialog_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_ = &PrintUnixDialog_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(gtk_print_unix_dialog_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void PrintUnixDialog_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* PrintUnixDialog_Class::wrap_new(GObject* o)
-{
-  return manage(new PrintUnixDialog((GtkPrintUnixDialog*)(o)));
-
-}
-
-
-/* The implementation: */
-
-PrintUnixDialog::PrintUnixDialog(const Glib::ConstructParams& construct_params)
-:
-  Gtk::Dialog(construct_params)
-{
-  }
-
-PrintUnixDialog::PrintUnixDialog(GtkPrintUnixDialog* castitem)
-:
-  Gtk::Dialog((GtkDialog*)(castitem))
-{
-  }
-
-PrintUnixDialog::~PrintUnixDialog()
-{
-  destroy_();
-}
-
-PrintUnixDialog::CppClassType PrintUnixDialog::printunixdialog_class_; // initialize static member
-
-GType PrintUnixDialog::get_type()
-{
-  return printunixdialog_class_.init().get_type();
-}
-
-GType PrintUnixDialog::get_base_type()
-{
-  return gtk_print_unix_dialog_get_type();
-}
-
-
-void PrintUnixDialog::set_page_setup(const Glib::RefPtr<PageSetup>& page_setup)
-{
-gtk_print_unix_dialog_set_page_setup(gobj(), Glib::unwrap(page_setup)); 
-}
-
-Glib::RefPtr<PageSetup> PrintUnixDialog::get_page_setup()
-{
-
-  Glib::RefPtr<PageSetup> retvalue = Glib::wrap(gtk_print_unix_dialog_get_page_setup(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const PageSetup> PrintUnixDialog::get_page_setup() const
-{
-  return const_cast<PrintUnixDialog*>(this)->get_page_setup();
-}
-
-void PrintUnixDialog::set_current_page(int current_page)
-{
-gtk_print_unix_dialog_set_current_page(gobj(), current_page); 
-}
-
-int PrintUnixDialog::get_current_page() const
-{
-  return gtk_print_unix_dialog_get_current_page(const_cast<GtkPrintUnixDialog*>(gobj()));
-}
-
-void PrintUnixDialog::set_settings(const Glib::RefPtr<PrintSettings>& print_settings)
-{
-gtk_print_unix_dialog_set_settings(gobj(), Glib::unwrap(print_settings)); 
-}
-
-Glib::RefPtr<PrintSettings> PrintUnixDialog::get_settings()
-{
-
-  Glib::RefPtr<PrintSettings> retvalue = Glib::wrap(gtk_print_unix_dialog_get_settings(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const PrintSettings> PrintUnixDialog::get_settings() const
-{
-  return const_cast<PrintUnixDialog*>(this)->get_settings();
-}
-
-Glib::RefPtr<Printer> PrintUnixDialog::get_selected_printer()
-{
-
-  Glib::RefPtr<Printer> retvalue = Glib::wrap(gtk_print_unix_dialog_get_selected_printer(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const Printer> PrintUnixDialog::get_selected_printer() const
-{
-
-  Glib::RefPtr<const Printer> retvalue = Glib::wrap(gtk_print_unix_dialog_get_selected_printer(const_cast<GtkPrintUnixDialog*>(gobj())));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-void PrintUnixDialog::add_custom_tab(const Widget& child, const Widget& tab_label)
-{
-gtk_print_unix_dialog_add_custom_tab(gobj(), const_cast<GtkWidget*>((child).gobj()), const_cast<GtkWidget*>((tab_label).gobj())); 
-}
-
-void PrintUnixDialog::set_manual_capabilities(PrintCapabilities capabilities)
-{
-gtk_print_unix_dialog_set_manual_capabilities(gobj(), ((GtkPrintCapabilities)(capabilities))); 
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy< Glib::RefPtr<PageSetup> > PrintUnixDialog::property_page_setup() 
-{
-  return Glib::PropertyProxy< Glib::RefPtr<PageSetup> >(this, "page-setup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PageSetup> > PrintUnixDialog::property_page_setup() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PageSetup> >(this, "page-setup");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> PrintUnixDialog::property_current_page() 
-{
-  return Glib::PropertyProxy<int>(this, "current-page");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> PrintUnixDialog::property_current_page() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "current-page");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy< Glib::RefPtr<PrintSettings> > PrintUnixDialog::property_print_settings() 
-{
-  return Glib::PropertyProxy< Glib::RefPtr<PrintSettings> >(this, "print-settings");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PrintSettings> > PrintUnixDialog::property_print_settings() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<PrintSettings> >(this, "print-settings");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Printer> > PrintUnixDialog::property_selected_printer() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Printer> >(this, "selected-printer");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/printunixdialog.h b/libs/gtkmm2/gtk/gtkmm/printunixdialog.h
deleted file mode 100644
index 89bc2d9638..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/printunixdialog.h
+++ /dev/null
@@ -1,249 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTUNIXDIALOG_H
-#define _GTKMM_PRINTUNIXDIALOG_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/dialog.h>
-#include <gtkmm/pagesetup.h>
-#include <gtkmm/printer.h>
-#include <gtkmm/printjob.h>
-#include <gtkmm/printsettings.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkPrintUnixDialog GtkPrintUnixDialog;
-typedef struct _GtkPrintUnixDialogClass GtkPrintUnixDialogClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class PrintUnixDialog_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** PrintUnixDialog implements a print dialog for platforms
- * which don't provide a native print dialog, like Unix. It can 
- * be used very much like any other GTK+ dialog, at the cost of 
- * the portability offered by the high-level printing API exposed
- * through PrintOperation.
- *
- * In order to print something with PrintUnixDialog, you need
- * to use get_selected_printer() to obtain a Printer object and
- * use it to construct a PrintJob using PrintJob::create().
- *
- * PrintUnixDialog uses the following response values:
- * - RESPONSE_OK for the "Print" button
- * - RESPONSE_APPLY for the "Preview" button
- * - RESPONSE_CANCEL for the "Cancel" button
- *
- * @newin2p10
- *
- * @ingroup Printing
- */
-
-class PrintUnixDialog : public Dialog
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PrintUnixDialog CppObjectType;
-  typedef PrintUnixDialog_Class CppClassType;
-  typedef GtkPrintUnixDialog BaseObjectType;
-  typedef GtkPrintUnixDialogClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~PrintUnixDialog();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class PrintUnixDialog_Class;
-  static CppClassType printunixdialog_class_;
-
-  // noncopyable
-  PrintUnixDialog(const PrintUnixDialog&);
-  PrintUnixDialog& operator=(const PrintUnixDialog&);
-
-protected:
-  explicit PrintUnixDialog(const Glib::ConstructParams& construct_params);
-  explicit PrintUnixDialog(GtkPrintUnixDialog* 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.
-  GtkPrintUnixDialog*       gobj()       { return reinterpret_cast<GtkPrintUnixDialog*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkPrintUnixDialog* gobj() const { return reinterpret_cast<GtkPrintUnixDialog*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-  //This is not available in on Win32.
-//This source file will not be compiled,
-//and the class will not be registered in wrap_init.h or wrap_init.cc
-
-
-public:
-  explicit PrintUnixDialog(Gtk::Window& parent, const Glib::ustring& title);
-  explicit PrintUnixDialog(const Glib::ustring& title);
-
-  
-  void set_page_setup(const Glib::RefPtr<PageSetup>& page_setup);
-  
-  Glib::RefPtr<PageSetup> get_page_setup();
-  
-  Glib::RefPtr<const PageSetup> get_page_setup() const;
-
-  
-  void set_current_page(int current_page);
-  
-  int get_current_page() const;
-
-  
-  void set_settings(const Glib::RefPtr<PrintSettings>& print_settings);
-  
-  Glib::RefPtr<PrintSettings> get_settings();
-  
-  Glib::RefPtr<const PrintSettings> get_settings() const;
-
-   
-  Glib::RefPtr<Printer> get_selected_printer();
-  
-  Glib::RefPtr<const Printer> get_selected_printer() const;
-
-  void add_custom_tab(const Widget& child, const Glib::ustring& tab_label);
-  
-  void add_custom_tab(const Widget& child, const Widget& tab_label);
-  
-  void set_manual_capabilities(PrintCapabilities capabilities);
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPageSetup to use.
-   *
-   * 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<PageSetup> > property_page_setup() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPageSetup to use.
-   *
-   * 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<PageSetup> > property_page_setup() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current page in the document.
-   *
-   * 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_current_page() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The current page in the document.
-   *
-   * 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_current_page() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPrintSettings used for initializing the dialog.
-   *
-   * 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<PrintSettings> > property_print_settings() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPrintSettings used for initializing the dialog.
-   *
-   * 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<PrintSettings> > property_print_settings() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkPrinter which is selected.
-   *
-   * 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<Printer> > property_selected_printer() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::PrintUnixDialog
-   * @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.
-   */
-  Gtk::PrintUnixDialog* wrap(GtkPrintUnixDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_PRINTUNIXDIALOG_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h
index 6aa9bce748..60a53a69ba 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/aboutdialog_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ABOUTDIALOG_P_H
 #define _GTKMM_ABOUTDIALOG_P_H
-
-
 #include <gtkmm/private/dialog_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ABOUTDIALOG_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h
index 2b12fd4c10..6caa6d52e4 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/accelgroup_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ACCELGROUP_P_H
 #define _GTKMM_ACCELGROUP_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 accel_changed_callback(GtkAccelGroup* self, guint p0, GdkModifierType p1, GClosure* p2);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ACCELGROUP_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h b/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h
index 16f155b34d..fea48d72d6 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/accellabel_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ACCELLABEL_P_H
 #define _GTKMM_ACCELLABEL_P_H
-
-
 #include <gtkmm/private/label_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ACCELLABEL_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/action_p.h b/libs/gtkmm2/gtk/gtkmm/private/action_p.h
index 50cff0cc7c..b143a7e57d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/action_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/action_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ACTION_P_H
 #define _GTKMM_ACTION_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,25 +30,20 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 activate_callback(GtkAction* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static GtkWidget* create_menu_item_vfunc_callback(GtkAction* self);
   static GtkWidget* create_tool_item_vfunc_callback(GtkAction* self);
   static void connect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy);
   static void disconnect_proxy_vfunc_callback(GtkAction* self, GtkWidget* proxy);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ACTION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h
index 36ae005e63..468723aa92 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/actiongroup_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ACTIONGROUP_P_H
 #define _GTKMM_ACTIONGROUP_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ACTIONGROUP_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h b/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h
index 13b1041b9f..4a13ed8c2b 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/adjustment_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ADJUSTMENT_P_H
 #define _GTKMM_ADJUSTMENT_P_H
-
-
 #include <gtkmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 changed_callback(GtkAdjustment* self);
   static void value_changed_callback(GtkAdjustment* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ADJUSTMENT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h b/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h
index dca8be1aec..debf6ee966 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/alignment_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ALIGNMENT_P_H
 #define _GTKMM_ALIGNMENT_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ALIGNMENT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h b/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h
index d833de7b09..7e3e5dd4b7 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/arrow_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ARROW_P_H
 #define _GTKMM_ARROW_P_H
-
-
 #include <gtkmm/private/misc_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ARROW_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h b/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h
index 50de94b4a6..6e5e3ec8b9 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/aspectframe_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ASPECTFRAME_P_H
 #define _GTKMM_ASPECTFRAME_P_H
-
-
 #include <gtkmm/private/frame_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ASPECTFRAME_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/assistant_p.h b/libs/gtkmm2/gtk/gtkmm/private/assistant_p.h
deleted file mode 100644
index 069325aaf8..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/assistant_p.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_ASSISTANT_P_H
-#define _GTKMM_ASSISTANT_P_H
-
-
-#include <gtkmm/private/window_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class Assistant_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef Assistant CppObjectType;
-  typedef GtkAssistant BaseObjectType;
-  typedef GtkAssistantClass BaseClassType;
-  typedef Gtk::Window_Class CppClassParent;
-  typedef GtkWindowClass BaseClassParent;
-
-  friend class Assistant;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 prepare_callback(GtkAssistant* self, GtkWidget* p0);
-  static void apply_callback(GtkAssistant* self);
-  static void close_callback(GtkAssistant* self);
-  static void cancel_callback(GtkAssistant* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_ASSISTANT_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/bin_p.h b/libs/gtkmm2/gtk/gtkmm/private/bin_p.h
index 09f64b7239..b81931b19e 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/bin_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/bin_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_BIN_P_H
 #define _GTKMM_BIN_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_BIN_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/box_p.h b/libs/gtkmm2/gtk/gtkmm/private/box_p.h
index fd04647034..bf26cdbf7d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/box_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/box_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_BOX_P_H
 #define _GTKMM_BOX_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,15 +30,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -73,15 +67,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -114,20 +104,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_BOX_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/button_p.h b/libs/gtkmm2/gtk/gtkmm/private/button_p.h
index 4507ddd23c..7fe15f9a48 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/button_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/button_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_BUTTON_P_H
 #define _GTKMM_BUTTON_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -42,16 +39,12 @@ protected:
   static void enter_callback(GtkButton* self);
   static void leave_callback(GtkButton* self);
   static void activate_callback(GtkButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_BUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h b/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h
index 722d1c87e5..59a656dbb5 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/buttonbox_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_BUTTONBOX_P_H
 #define _GTKMM_BUTTONBOX_P_H
-
-
 #include <gtkmm/private/box_p.h>
 
 #include <glibmm/class.h>
@@ -32,15 +30,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -73,15 +67,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -114,20 +104,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_BUTTONBOX_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h b/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h
index 0b6e4717ab..f138739966 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/calendar_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CALENDAR_P_H
 #define _GTKMM_CALENDAR_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -43,16 +40,12 @@ protected:
   static void next_month_callback(GtkCalendar* self);
   static void prev_year_callback(GtkCalendar* self);
   static void next_year_callback(GtkCalendar* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CALENDAR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h b/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h
index 6f49bf61d9..31250f561b 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/celleditable_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLEDITABLE_P_H
 #define _GTKMM_CELLEDITABLE_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,23 +27,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 editing_done_callback(GtkCellEditable* self);
   static void remove_widget_callback(GtkCellEditable* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void start_editing_vfunc_callback(GtkCellEditable* self, GdkEvent* event);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLEDITABLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h b/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h
index f1856c6a23..1af5318448 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/celllayout_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLLAYOUT_P_H
 #define _GTKMM_CELLLAYOUT_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,26 +27,21 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void pack_start_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand);
   static void pack_end_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gboolean expand);
   static void clear_vfunc_callback(GtkCellLayout* self);
   static void add_attribute_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, const gchar* attribute, gint column);
   static void clear_attributes_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell);
   static void reorder_vfunc_callback(GtkCellLayout* self, GtkCellRenderer* cell, gint position);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLLAYOUT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h
index b2ea9f3057..c7fac80cb6 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderer_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLRENDERER_P_H
 #define _GTKMM_CELLRENDERER_P_H
-
-
 #include <gtkmm/private/object_p.h>
 #include <gtk/gtkcellrenderer.h>
 
@@ -33,25 +31,20 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 editing_canceled_callback(GtkCellRenderer* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void get_size_vfunc_callback(GtkCellRenderer* self, GtkWidget* widget, GdkRectangle* cell_area, gint* x_offset, gint* y_offset, gint* width, gint* height);
   static void render_vfunc_callback(GtkCellRenderer* self, GdkDrawable* window, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GdkRectangle* expose_area, GtkCellRendererState flags);
   static gboolean activate_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags);
   static GtkCellEditable* start_editing_vfunc_callback(GtkCellRenderer* self, GdkEvent* event, GtkWidget* widget, const gchar* path, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLRENDERER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendereraccel_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendereraccel_p.h
deleted file mode 100644
index abf103dcf7..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrendereraccel_p.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_CELLRENDERERACCEL_P_H
-#define _GTKMM_CELLRENDERERACCEL_P_H
-
-
-#include <gtkmm/private/cellrenderertext_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class CellRendererAccel_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef CellRendererAccel CppObjectType;
-  typedef GtkCellRendererAccel BaseObjectType;
-  typedef GtkCellRendererAccelClass BaseClassType;
-  typedef Gtk::CellRendererText_Class CppClassParent;
-  typedef GtkCellRendererTextClass BaseClassParent;
-
-  friend class CellRendererAccel;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 accel_edited_callback(GtkCellRendererAccel* self, const gchar* p0, guint p1, GdkModifierType p2, guint p3);
-  static void accel_cleared_callback(GtkCellRendererAccel* self, const gchar* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_CELLRENDERERACCEL_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h
index 3bb865fe85..af5eda9c5f 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderercombo_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLRENDERERCOMBO_P_H
 #define _GTKMM_CELLRENDERERCOMBO_P_H
-
-
 #include <gtkmm/private/cellrenderertext_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLRENDERERCOMBO_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h
index bb9637648b..5bf100b376 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrendererpixbuf_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLRENDERERPIXBUF_P_H
 #define _GTKMM_CELLRENDERERPIXBUF_P_H
-
-
 #include <gtkmm/private/cellrenderer_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLRENDERERPIXBUF_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h
index 7e6f491be9..f95a9f133b 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrendererprogress_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLRENDERERPROGRESS_P_H
 #define _GTKMM_CELLRENDERERPROGRESS_P_H
-
-
 #include <gtkmm/private/cellrenderer_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLRENDERERPROGRESS_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrendererspin_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrendererspin_p.h
deleted file mode 100644
index f4153154a4..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrendererspin_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_CELLRENDERERSPIN_P_H
-#define _GTKMM_CELLRENDERERSPIN_P_H
-
-
-#include <gtkmm/private/cellrenderertext_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class CellRendererSpin_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef CellRendererSpin CppObjectType;
-  typedef GtkCellRendererSpin BaseObjectType;
-  typedef GtkCellRendererSpinClass BaseClassType;
-  typedef Gtk::CellRendererText_Class CppClassParent;
-  typedef GtkCellRendererTextClass BaseClassParent;
-
-  friend class CellRendererSpin;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_CELLRENDERERSPIN_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h
index 982bd5121c..1505a568f9 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertext_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLRENDERERTEXT_P_H
 #define _GTKMM_CELLRENDERERTEXT_P_H
-
-
 #include <gtkmm/private/cellrenderer_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 edited_callback(GtkCellRendererText* self, const gchar* p0, const gchar* p1);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLRENDERERTEXT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h
index 5dae657ee1..6566624b9d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellrenderertoggle_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLRENDERERTOGGLE_P_H
 #define _GTKMM_CELLRENDERERTOGGLE_P_H
-
-
 #include <gtkmm/private/cellrenderer_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 toggled_callback(GtkCellRendererToggle* self, const gchar* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLRENDERERTOGGLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h b/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h
index 1fbe8887e2..6046537896 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/cellview_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CELLVIEW_P_H
 #define _GTKMM_CELLVIEW_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CELLVIEW_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h
index 7addfe36b5..1e579d79b9 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/checkbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CHECKBUTTON_P_H
 #define _GTKMM_CHECKBUTTON_P_H
-
-
 #include <gtkmm/private/togglebutton_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void draw_indicator_vfunc_callback(GtkCheckButton* self, GdkRectangle* area);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CHECKBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h
index 4c720e1207..8ae77c14b7 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/checkmenuitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CHECKMENUITEM_P_H
 #define _GTKMM_CHECKMENUITEM_P_H
-
-
 #include <gtkmm/private/menuitem_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 toggled_callback(GtkCheckMenuItem* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void draw_indicator_vfunc_callback(GtkCheckMenuItem* self, GdkRectangle* area);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CHECKMENUITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h b/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h
index b5e26cc290..1bad952a67 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/clipboard_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CLIPBOARD_P_H
 #define _GTKMM_CLIPBOARD_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CLIPBOARD_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h
index a46181fa2c..20b2dfb9e6 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/colorbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_COLORBUTTON_P_H
 #define _GTKMM_COLORBUTTON_P_H
-
-
 #include <gtkmm/private/button_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 color_set_callback(GtkColorButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_COLORBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h
index d583cc3e7b..662aca3486 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/colorselection_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_COLORSELECTION_P_H
 #define _GTKMM_COLORSELECTION_P_H
-
-
 #include <gtkmm/private/box_p.h>
 #include <gtkmm/private/dialog_p.h>
 
@@ -33,16 +31,12 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 color_changed_callback(GtkColorSelection* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -75,20 +69,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_COLORSELECTION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/combo_p.h b/libs/gtkmm2/gtk/gtkmm/private/combo_p.h
index 23c1aaf402..c272fe4afa 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/combo_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/combo_p.h
@@ -2,9 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_COMBO_P_H
 #define _GTKMM_COMBO_P_H
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <gtkmm/private/box_p.h>
 #include <gtkmm/private/item_p.h>
 
@@ -34,17 +31,13 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 scroll_horizontal_callback(GtkListItem* self, GtkScrollType p0, gfloat p1);
   static void scroll_vertical_callback(GtkListItem* self, GtkScrollType p0, gfloat p1);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -77,18 +70,14 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 select_child_callback(GtkList* self, GtkWidget* p0);
   static void selection_changed_callback(GtkList* self);
   static void unselect_child_callback(GtkList* self, GtkWidget* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -121,22 +110,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
 #endif /* _GTKMM_COMBO_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h b/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h
index d2ec16e76b..242c755f70 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/combobox_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_COMBOBOX_P_H
 #define _GTKMM_COMBOBOX_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 changed_callback(GtkComboBox* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_COMBOBOX_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h b/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h
index 01d4ba8ec2..bbc8a5028a 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/comboboxentry_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_COMBOBOXENTRY_P_H
 #define _GTKMM_COMBOBOXENTRY_P_H
-
-
 #include <gtkmm/private/combobox_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_COMBOBOXENTRY_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/container_p.h b/libs/gtkmm2/gtk/gtkmm/private/container_p.h
index 0b917095dc..3f1b158887 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/container_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/container_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CONTAINER_P_H
 #define _GTKMM_CONTAINER_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -41,22 +38,18 @@ protected:
   static void check_resize_callback(GtkContainer* self);
   static void set_focus_child_callback(GtkContainer* self, GtkWidget* p0);
     static void destroy_callback(GtkObject* self);
-    static void remove_callback_normal(GtkContainer* self, GtkWidget* p0);
-  #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
+      static void remove_callback_custom(GtkContainer* self, GtkWidget* p0);
+  
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static GtkType child_type_vfunc_callback(GtkContainer* self);
   static void forall_vfunc_callback(GtkContainer* self, gboolean include_internals, GtkCallback callback, gpointer callback_data);
   static gchar* composite_name_vfunc_callback(GtkContainer* self, GtkWidget* child);
   static void set_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, const GValue* value, GParamSpec* pspec);
   static void get_child_property_vfunc_callback(GtkContainer* self, GtkWidget* child, guint property_id, GValue* value, GParamSpec* pspec);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CONTAINER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/curve_p.h b/libs/gtkmm2/gtk/gtkmm/private/curve_p.h
index a99ce85c20..dc07066521 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/curve_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/curve_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_CURVE_P_H
 #define _GTKMM_CURVE_P_H
-
-
 #include <gtkmm/private/drawingarea_p.h>
 #include <gtkmm/private/box_p.h>
 
@@ -33,16 +31,12 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 curve_type_changed_callback(GtkCurve* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -75,20 +69,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_CURVE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h
index b5f4515bc8..9eeef1e8fe 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/dialog_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_DIALOG_P_H
 #define _GTKMM_DIALOG_P_H
-
-
 #include <gtkmm/private/window_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 response_callback(GtkDialog* self, gint p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_DIALOG_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h b/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h
index d1aaf767f7..cd639999b3 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/drawingarea_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_DRAWINGAREA_P_H
 #define _GTKMM_DRAWINGAREA_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_DRAWINGAREA_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/editable_p.h b/libs/gtkmm2/gtk/gtkmm/private/editable_p.h
index 394b2f0ce9..caf727830a 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/editable_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/editable_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_EDITABLE_P_H
 #define _GTKMM_EDITABLE_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,17 +27,14 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 insert_text_callback(GtkEditable* self, const gchar* text, gint length, gint* position);
   static void delete_text_callback(GtkEditable* self, gint start_pos, gint end_pos);
   static void changed_callback(GtkEditable* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void do_insert_text_vfunc_callback(GtkEditable* self, const gchar* text, gint length, gint* position);
   static void do_delete_text_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos);
   static gchar* get_chars_vfunc_callback(GtkEditable* self, gint start_pos, gint end_pos);
@@ -47,12 +42,10 @@ protected:
   static gboolean get_selection_bounds_vfunc_callback(GtkEditable* self, gint* start_pos, gint* end_pos);
   static void set_position_vfunc_callback(GtkEditable* self, gint position);
   static gint get_position_vfunc_callback(GtkEditable* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_EDITABLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/entry_p.h b/libs/gtkmm2/gtk/gtkmm/private/entry_p.h
index 3a9c2f5749..5d25b64902 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/entry_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/entry_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ENTRY_P_H
 #define _GTKMM_ENTRY_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,23 +30,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 populate_popup_callback(GtkEntry* self, GtkMenu* p0);
   static void insert_at_cursor_callback(GtkEntry* self, const gchar* p0);
   static void activate_callback(GtkEntry* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ENTRY_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h b/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h
index 79d484712d..2a9b97a3ad 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/entrycompletion_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ENTRYCOMPLETION_P_H
 #define _GTKMM_ENTRYCOMPLETION_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 action_activated_callback(GtkEntryCompletion* self, gint p0);
     static gboolean match_selected_callback_custom(GtkEntryCompletion* self, GtkTreeModel* c_model, GtkTreeIter* c_iter);
-  #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
+  
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ENTRYCOMPLETION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/enums_p.h b/libs/gtkmm2/gtk/gtkmm/private/enums_p.h
index a615673112..68c26cc900 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/enums_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/enums_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ENUMS_P_H
 #define _GTKMM_ENUMS_P_H
-
-
 #endif /* _GTKMM_ENUMS_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h b/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h
index c77f337743..91b3303f1f 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/eventbox_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_EVENTBOX_P_H
 #define _GTKMM_EVENTBOX_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_EVENTBOX_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/expander_p.h b/libs/gtkmm2/gtk/gtkmm/private/expander_p.h
index fa106764f7..674bf038cd 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/expander_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/expander_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_EXPANDER_P_H
 #define _GTKMM_EXPANDER_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_EXPANDER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h
index 3c3843a06a..9b864a7dda 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooser_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FILECHOOSER_P_H
 #define _GTKMM_FILECHOOSER_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,20 +27,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FILECHOOSER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h
index c555b834a1..60aa6eff06 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FILECHOOSERBUTTON_P_H
 #define _GTKMM_FILECHOOSERBUTTON_P_H
-
-
 #include <gtkmm/private/box_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FILECHOOSERBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h
index 00d39137e7..38e4d9aa12 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserdialog_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FILECHOOSERDIALOG_P_H
 #define _GTKMM_FILECHOOSERDIALOG_P_H
-
-
 #include <gtkmm/private/dialog_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FILECHOOSERDIALOG_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h b/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h
index c157717aa9..09e093dca1 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/filechooserwidget_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FILECHOOSERWIDGET_P_H
 #define _GTKMM_FILECHOOSERWIDGET_P_H
-
-
 #include <gtkmm/private/box_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FILECHOOSERWIDGET_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h b/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h
index dc6fada76d..cfc5b84d36 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/filefilter_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FILEFILTER_P_H
 #define _GTKMM_FILEFILTER_P_H
-
-
 #include <gtkmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FILEFILTER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h
index 6028f0e076..9ab7fc7c1f 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/fileselection_p.h
@@ -2,9 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FILESELECTION_P_H
 #define _GTKMM_FILESELECTION_P_H
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <gtkmm/private/dialog_p.h>
 
 #include <glibmm/class.h>
@@ -33,22 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
 #endif /* _GTKMM_FILESELECTION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h b/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h
index 066e44408b..b1c4abe756 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/fixed_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FIXED_P_H
 #define _GTKMM_FIXED_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FIXED_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h
index 9234c1123a..746f160914 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/fontbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FONTBUTTON_P_H
 #define _GTKMM_FONTBUTTON_P_H
-
-
 #include <gtkmm/private/button_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 font_set_callback(GtkFontButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FONTBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h
index a7737b28a9..50da4e3401 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/fontselection_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FONTSELECTION_P_H
 #define _GTKMM_FONTSELECTION_P_H
-
-
 #include <gtkmm/private/box_p.h>
 #include <gtkmm/private/dialog_p.h>
 
@@ -33,15 +31,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -74,20 +68,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FONTSELECTION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/frame_p.h b/libs/gtkmm2/gtk/gtkmm/private/frame_p.h
index daefa92adf..297c7efbe7 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/frame_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/frame_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_FRAME_P_H
 #define _GTKMM_FRAME_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void compute_child_allocation_vfunc_callback(GtkFrame* self, GtkAllocation* allocation);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_FRAME_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h b/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h
index b6d44d852f..d1e0b3c30d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/handlebox_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_HANDLEBOX_P_H
 #define _GTKMM_HANDLEBOX_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 child_attached_callback(GtkHandleBox* self, GtkWidget* p0);
   static void child_detached_callback(GtkHandleBox* self, GtkWidget* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_HANDLEBOX_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h
index bfa19c2ca1..8840e8abde 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconfactory_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ICONFACTORY_P_H
 #define _GTKMM_ICONFACTORY_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ICONFACTORY_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h
index 2aef33386c..e391510843 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconinfo_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ICONINFO_P_H
 #define _GTKMM_ICONINFO_P_H
-
-
 #endif /* _GTKMM_ICONINFO_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h
index 33da9a49f9..1e861df94c 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconset_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ICONSET_P_H
 #define _GTKMM_ICONSET_P_H
-
-
 #endif /* _GTKMM_ICONSET_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h
index aeb78c2444..304da67691 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconsource_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ICONSOURCE_P_H
 #define _GTKMM_ICONSOURCE_P_H
-
-
 #endif /* _GTKMM_ICONSOURCE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h b/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h
index b2e6c34188..a54fdbc17e 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/icontheme_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ICONTHEME_P_H
 #define _GTKMM_ICONTHEME_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 changed_callback(GtkIconTheme* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ICONTHEME_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h b/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h
index bfa816a3a1..beed996eda 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/iconview_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ICONVIEW_P_H
 #define _GTKMM_ICONVIEW_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,23 +30,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 set_scroll_adjustments_callback(GtkIconView* self, GtkAdjustment* p0, GtkAdjustment* p1);
   static void item_activated_callback(GtkIconView* self, GtkTreePath* p0);
   static void selection_changed_callback(GtkIconView* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ICONVIEW_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/image_p.h b/libs/gtkmm2/gtk/gtkmm/private/image_p.h
index c5b5be8943..c01599d6c7 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/image_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/image_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_IMAGE_P_H
 #define _GTKMM_IMAGE_P_H
-
-
 #include <gtkmm/private/misc_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_IMAGE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h
index 0b7aac5ce4..4099489f25 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/imagemenuitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_IMAGEMENUITEM_P_H
 #define _GTKMM_IMAGEMENUITEM_P_H
-
-
 #include <gtkmm/private/menuitem_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_IMAGEMENUITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h
index 4614bbb0c9..3197f6efb5 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/inputdialog_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_INPUTDIALOG_P_H
 #define _GTKMM_INPUTDIALOG_P_H
-
-
 #include <gtkmm/private/dialog_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 enable_device_callback(GtkInputDialog* self, GdkDevice* p0);
   static void disable_device_callback(GtkInputDialog* self, GdkDevice* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_INPUTDIALOG_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h b/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h
index f40d446263..0709dc8989 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/invisible_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_INVISIBLE_P_H
 #define _GTKMM_INVISIBLE_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_INVISIBLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/item_p.h b/libs/gtkmm2/gtk/gtkmm/private/item_p.h
index f2fdb82d98..2baa4fa0de 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/item_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/item_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_ITEM_P_H
 #define _GTKMM_ITEM_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,23 +30,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 select_callback(GtkItem* self);
   static void deselect_callback(GtkItem* self);
   static void toggle_callback(GtkItem* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_ITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/label_p.h b/libs/gtkmm2/gtk/gtkmm/private/label_p.h
index 9975ec5a69..5254aba319 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/label_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/label_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_LABEL_P_H
 #define _GTKMM_LABEL_P_H
-
-
 #include <gtkmm/private/misc_p.h>
 #include <gtk/gtkmenu.h>
 
@@ -33,21 +31,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 populate_popup_callback(GtkLabel* self, GtkMenu* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_LABEL_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/layout_p.h b/libs/gtkmm2/gtk/gtkmm/private/layout_p.h
index b2ba71311d..1c4c2773c5 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/layout_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/layout_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_LAYOUT_P_H
 #define _GTKMM_LAYOUT_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 set_scroll_adjustments_callback(GtkLayout* self, GtkAdjustment* p0, GtkAdjustment* p1);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_LAYOUT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/linkbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/linkbutton_p.h
deleted file mode 100644
index 4b8d931b35..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/linkbutton_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_LINKBUTTON_P_H
-#define _GTKMM_LINKBUTTON_P_H
-
-
-#include <gtkmm/private/button_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class LinkButton_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef LinkButton CppObjectType;
-  typedef GtkLinkButton BaseObjectType;
-  typedef GtkLinkButtonClass BaseClassType;
-  typedef Gtk::Button_Class CppClassParent;
-  typedef GtkButtonClass BaseClassParent;
-
-  friend class LinkButton;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_LINKBUTTON_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h b/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h
index e2703acf31..522ec0b0ca 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/liststore_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_LISTSTORE_P_H
 #define _GTKMM_LISTSTORE_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_LISTSTORE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/main_p.h b/libs/gtkmm2/gtk/gtkmm/private/main_p.h
index bf8d4f1c14..a911a52b39 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/main_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/main_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MAIN_P_H
 #define _GTKMM_MAIN_P_H
-
-
 #endif /* _GTKMM_MAIN_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menu_p.h b/libs/gtkmm2/gtk/gtkmm/private/menu_p.h
index 65094515e9..97d6e21f30 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/menu_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/menu_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MENU_P_H
 #define _GTKMM_MENU_P_H
-
-
 #include <gtkmm/private/menushell_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_MENU_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h b/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h
index bb1654a33e..e36353f8c6 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/menubar_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MENUBAR_P_H
 #define _GTKMM_MENUBAR_P_H
-
-
 #include <gtkmm/private/menushell_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_MENUBAR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h
index 176454115f..c900ddc67f 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/menuitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MENUITEM_P_H
 #define _GTKMM_MENUITEM_P_H
-
-
 #include <gtkmm/private/item_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -40,16 +37,12 @@ protected:
   static void activate_item_callback(GtkMenuItem* self);
   static void toggle_size_request_callback(GtkMenuItem* self, int* p0);
   static void toggle_size_allocate_callback(GtkMenuItem* self, gint p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_MENUITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h b/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h
index 0f61b21960..676e85d40e 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/menushell_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MENUSHELL_P_H
 #define _GTKMM_MENUSHELL_P_H
-
-
 #include <gtkmm/private/container_p.h>
 #include <gtkmm/menu.h>
 #include <gtkmm/menubar.h>
@@ -35,25 +33,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 deactivate_callback(GtkMenuShell* self);
   static void selection_done_callback(GtkMenuShell* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED //We always need insert_vfunc_callback
     static void insert_vfunc_callback(GtkMenuShell* self, GtkWidget* child, int position);
-#ifdef GLIBMM_VFUNCS_ENABLED
-  #endif //GLIBMM_VFUNCS_ENABLED
-};
+  };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_MENUSHELL_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h
index 406e62c66e..401e1b5242 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/menutoolbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MENUTOOLBUTTON_P_H
 #define _GTKMM_MENUTOOLBUTTON_P_H
-
-
 #include <gtkmm/private/toolbutton_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 show_menu_callback(GtkMenuToolButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_MENUTOOLBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h
index 1008f62611..829b79c77e 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/messagedialog_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MESSAGEDIALOG_P_H
 #define _GTKMM_MESSAGEDIALOG_P_H
-
-
 #include <gtkmm/private/dialog_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_MESSAGEDIALOG_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/misc_p.h b/libs/gtkmm2/gtk/gtkmm/private/misc_p.h
index a91becd7d2..adeb898dfe 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/misc_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/misc_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_MISC_P_H
 #define _GTKMM_MISC_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_MISC_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h b/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h
index 5b1195fb82..de761d21c9 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/notebook_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_NOTEBOOK_P_H
 #define _GTKMM_NOTEBOOK_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 switch_page_callback(GtkNotebook* self, GtkNotebookPage* p0, guint p1);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_NOTEBOOK_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/object_p.h b/libs/gtkmm2/gtk/gtkmm/private/object_p.h
index 278007208a..dc4ba98bef 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/object_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/object_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_OBJECT_P_H
 #define _GTKMM_OBJECT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_OBJECT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h b/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h
index c035a660e4..414d3e631d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/optionmenu_p.h
@@ -2,9 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_OPTIONMENU_P_H
 #define _GTKMM_OPTIONMENU_P_H
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-
 #include <gtkmm/private/button_p.h>
 
 #include <glibmm/class.h>
@@ -33,23 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 changed_callback(GtkOptionMenu* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
 #endif /* _GTKMM_OPTIONMENU_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/pagesetupunixdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/pagesetupunixdialog_p.h
deleted file mode 100644
index 697f91a98b..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/pagesetupunixdialog_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PAGESETUPUNIXDIALOG_P_H
-#define _GTKMM_PAGESETUPUNIXDIALOG_P_H
-
-
-#include <gtkmm/private/dialog_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class PageSetupUnixDialog_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PageSetupUnixDialog CppObjectType;
-  typedef GtkPageSetupUnixDialog BaseObjectType;
-  typedef GtkPageSetupUnixDialogClass BaseClassType;
-  typedef Gtk::Dialog_Class CppClassParent;
-  typedef GtkDialogClass BaseClassParent;
-
-  friend class PageSetupUnixDialog;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PAGESETUPUNIXDIALOG_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/paned_p.h b/libs/gtkmm2/gtk/gtkmm/private/paned_p.h
index 7b17cccd0c..8d8af1f20d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/paned_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/paned_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_PANED_P_H
 #define _GTKMM_PANED_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,15 +30,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -73,15 +67,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -114,20 +104,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_PANED_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/papersize_p.h b/libs/gtkmm2/gtk/gtkmm/private/papersize_p.h
deleted file mode 100644
index 44388697b3..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/papersize_p.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PAPERSIZE_P_H
-#define _GTKMM_PAPERSIZE_P_H
-
-
-#endif /* _GTKMM_PAPERSIZE_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/plug_p.h b/libs/gtkmm2/gtk/gtkmm/private/plug_p.h
index 4e90a3d270..86c6e9b3f6 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/plug_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/plug_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_PLUG_P_H
 #define _GTKMM_PLUG_P_H
-
-
 #include <gtkmm/private/window_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 embedded_callback(GtkPlug* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_PLUG_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/printcontext_p.h b/libs/gtkmm2/gtk/gtkmm/private/printcontext_p.h
deleted file mode 100644
index a4102e31c4..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/printcontext_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTCONTEXT_P_H
-#define _GTKMM_PRINTCONTEXT_P_H
-
-
-#include <glibmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class PrintContext_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PrintContext CppObjectType;
-  typedef GtkPrintContext BaseObjectType;
-  typedef GtkPrintContextClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
-
-  friend class PrintContext;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PRINTCONTEXT_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/printer_p.h b/libs/gtkmm2/gtk/gtkmm/private/printer_p.h
deleted file mode 100644
index e694c97c1a..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/printer_p.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTER_P_H
-#define _GTKMM_PRINTER_P_H
-
-
-#include <glibmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class Printer_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef Printer CppObjectType;
-  typedef GtkPrinter BaseObjectType;
-  typedef GtkPrinterClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
-
-  friend class Printer;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 details_acquired_callback(GtkPrinter* self, gboolean p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PRINTER_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/printjob_p.h b/libs/gtkmm2/gtk/gtkmm/private/printjob_p.h
deleted file mode 100644
index c1ff73b205..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/printjob_p.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTJOB_P_H
-#define _GTKMM_PRINTJOB_P_H
-
-
-#include <glibmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class PrintJob_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PrintJob CppObjectType;
-  typedef GtkPrintJob BaseObjectType;
-  typedef GtkPrintJobClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
-
-  friend class PrintJob;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 status_changed_callback(GtkPrintJob* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PRINTJOB_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/printoperation_p.h b/libs/gtkmm2/gtk/gtkmm/private/printoperation_p.h
deleted file mode 100644
index 794ddf3949..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/printoperation_p.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTOPERATION_P_H
-#define _GTKMM_PRINTOPERATION_P_H
-
-
-#include <glibmm/private/object_p.h>
-#include <gtk/gtkprintoperation.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class PrintOperation_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PrintOperation CppObjectType;
-  typedef GtkPrintOperation BaseObjectType;
-  typedef GtkPrintOperationClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
-
-  friend class PrintOperation;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 done_callback(GtkPrintOperation* self, GtkPrintOperationResult p0);
-  static void begin_print_callback(GtkPrintOperation* self, GtkPrintContext* p0);
-  static gboolean paginate_callback(GtkPrintOperation* self, GtkPrintContext* p0);
-  static void request_page_setup_callback(GtkPrintOperation* self, GtkPrintContext* p0, gint p1, GtkPageSetup* p2);
-  static void draw_page_callback(GtkPrintOperation* self, GtkPrintContext* p0, gint p1);
-  static void end_print_callback(GtkPrintOperation* self, GtkPrintContext* p0);
-  static void status_changed_callback(GtkPrintOperation* self);
-  static GtkWidget* create_custom_widget_callback(GtkPrintOperation* self);
-  static void custom_widget_apply_callback(GtkPrintOperation* self, GtkWidget* p0);
-  static gboolean preview_callback(GtkPrintOperation* self, GtkPrintOperationPreview* p0, GtkPrintContext* p1, GtkWindow* p2);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PRINTOPERATION_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/printoperationpreview_p.h b/libs/gtkmm2/gtk/gtkmm/private/printoperationpreview_p.h
deleted file mode 100644
index 94cfe71962..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/printoperationpreview_p.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTOPERATIONPREVIEW_P_H
-#define _GTKMM_PRINTOPERATIONPREVIEW_P_H
-
-
-#include <glibmm/private/interface_p.h>
-
-#include <glibmm/private/interface_p.h>
-
-namespace Gtk
-{
-
-class PrintOperationPreview_Class : public Glib::Interface_Class
-{
-public:
-  typedef PrintOperationPreview CppObjectType;
-  typedef GtkPrintOperationPreview BaseObjectType;
-  typedef GtkPrintOperationPreviewIface BaseClassType;
-  typedef Glib::Interface_Class CppClassParent;
-
-  friend class PrintOperationPreview;
-
-  const Glib::Interface_Class& init();
-
-  static void iface_init_function(void* g_iface, void* iface_data);
-
-  static Glib::ObjectBase* wrap_new(GObject*);
-
-protected:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 ready_callback(GtkPrintOperationPreview* self, GtkPrintContext* p0);
-  static void got_page_size_callback(GtkPrintOperationPreview* self, GtkPrintContext* p0, GtkPageSetup* p1);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-  static void render_page_vfunc_callback(GtkPrintOperationPreview* self, gint page_nr);
-  static void end_preview_vfunc_callback(GtkPrintOperationPreview* self);
-  static gboolean is_selected_vfunc_callback(GtkPrintOperationPreview* self, gint page_nr);
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PRINTOPERATIONPREVIEW_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/printsettings_p.h b/libs/gtkmm2/gtk/gtkmm/private/printsettings_p.h
deleted file mode 100644
index 8297647ec9..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/printsettings_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTSETTINGS_P_H
-#define _GTKMM_PRINTSETTINGS_P_H
-
-
-#include <glibmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class PrintSettings_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PrintSettings CppObjectType;
-  typedef GtkPrintSettings BaseObjectType;
-  typedef GtkPrintSettingsClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
-
-  friend class PrintSettings;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PRINTSETTINGS_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/printunixdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/printunixdialog_p.h
deleted file mode 100644
index 8a55fc261c..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/printunixdialog_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PRINTUNIXDIALOG_P_H
-#define _GTKMM_PRINTUNIXDIALOG_P_H
-
-
-#include <gtkmm/private/dialog_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class PrintUnixDialog_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PrintUnixDialog CppObjectType;
-  typedef GtkPrintUnixDialog BaseObjectType;
-  typedef GtkPrintUnixDialogClass BaseClassType;
-  typedef Gtk::Dialog_Class CppClassParent;
-  typedef GtkDialogClass BaseClassParent;
-
-  friend class PrintUnixDialog;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_PRINTUNIXDIALOG_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h
index 833faec7b6..783de015ea 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/progressbar_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_PROGRESSBAR_P_H
 #define _GTKMM_PROGRESSBAR_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 #include <gtk/gtkprogress.h>
 
@@ -33,20 +31,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_PROGRESSBAR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h b/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h
index 9059f8a77e..ab9ae13b95 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/radioaction_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_RADIOACTION_P_H
 #define _GTKMM_RADIOACTION_P_H
-
-
 #include <gtkmm/private/toggleaction_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 changed_callback(GtkRadioAction* self, GtkRadioAction* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_RADIOACTION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h
index 23512be033..bb0797be6c 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/radiobutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_RADIOBUTTON_P_H
 #define _GTKMM_RADIOBUTTON_P_H
-
-
 #include <gtkmm/private/checkbutton_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 group_changed_callback(GtkRadioButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_RADIOBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h
index 79874f966e..aa49592fc7 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/radiomenuitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_RADIOMENUITEM_P_H
 #define _GTKMM_RADIOMENUITEM_P_H
-
-
 #include <gtkmm/private/checkmenuitem_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 group_changed_callback(GtkRadioMenuItem* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_RADIOMENUITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h
index 3d0e468fce..034902a829 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/radiotoolbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_RADIOTOOLBUTTON_P_H
 #define _GTKMM_RADIOTOOLBUTTON_P_H
-
-
 #include <gtkmm/private/toggletoolbutton_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_RADIOTOOLBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/range_p.h b/libs/gtkmm2/gtk/gtkmm/private/range_p.h
index de5a8cd9fc..78c6b0c5a3 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/range_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/range_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_RANGE_P_H
 #define _GTKMM_RANGE_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,24 +30,19 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 value_changed_callback(GtkRange* self);
   static void adjust_bounds_callback(GtkRange* self, gdouble p0);
   static void move_slider_callback(GtkRange* self, GtkScrollType p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void get_range_border_vfunc_callback(GtkRange* self, GtkBorder* border);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_RANGE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/rc_p.h b/libs/gtkmm2/gtk/gtkmm/private/rc_p.h
index fd253522b1..963495fb4f 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/rc_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/rc_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_RC_P_H
 #define _GTKMM_RC_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_RC_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/recentchooser_p.h b/libs/gtkmm2/gtk/gtkmm/private/recentchooser_p.h
deleted file mode 100644
index e4f0475a26..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/recentchooser_p.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSER_P_H
-#define _GTKMM_RECENTCHOOSER_P_H
-
-
-#include <glibmm/private/interface_p.h>
-
-#include <glibmm/private/interface_p.h>
-
-namespace Gtk
-{
-
-class RecentChooser_Class : public Glib::Interface_Class
-{
-public:
-  typedef RecentChooser CppObjectType;
-  typedef GtkRecentChooser BaseObjectType;
-  typedef GtkRecentChooserIface BaseClassType;
-  typedef Glib::Interface_Class CppClassParent;
-
-  friend class RecentChooser;
-
-  const Glib::Interface_Class& init();
-
-  static void iface_init_function(void* g_iface, void* iface_data);
-
-  static Glib::ObjectBase* wrap_new(GObject*);
-
-protected:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-  static gchar* get_current_uri_vfunc_callback(GtkRecentChooser* self);
-  static void unselect_uri_vfunc_callback(GtkRecentChooser* self, const gchar* uri);
-  static void select_all_vfunc_callback(GtkRecentChooser* self);
-  static void unselect_all_vfunc_callback(GtkRecentChooser* self);
-  static GtkRecentManager* get_recent_manager_vfunc_callback(GtkRecentChooser* self);
-  static void add_filter_vfunc_callback(GtkRecentChooser* self, GtkRecentFilter* filter);
-  static void remove_filter_vfunc_callback(GtkRecentChooser* self, GtkRecentFilter* filter);
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_RECENTCHOOSER_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/recentchooserdialog_p.h b/libs/gtkmm2/gtk/gtkmm/private/recentchooserdialog_p.h
deleted file mode 100644
index 4bd87e15af..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/recentchooserdialog_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSERDIALOG_P_H
-#define _GTKMM_RECENTCHOOSERDIALOG_P_H
-
-
-#include <gtkmm/private/dialog_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class RecentChooserDialog_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentChooserDialog CppObjectType;
-  typedef GtkRecentChooserDialog BaseObjectType;
-  typedef GtkRecentChooserDialogClass BaseClassType;
-  typedef Gtk::Dialog_Class CppClassParent;
-  typedef GtkDialogClass BaseClassParent;
-
-  friend class RecentChooserDialog;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_RECENTCHOOSERDIALOG_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/recentchoosermenu_p.h b/libs/gtkmm2/gtk/gtkmm/private/recentchoosermenu_p.h
deleted file mode 100644
index 39010afadd..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/recentchoosermenu_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSERMENU_P_H
-#define _GTKMM_RECENTCHOOSERMENU_P_H
-
-
-#include <gtkmm/private/menu_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class RecentChooserMenu_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentChooserMenu CppObjectType;
-  typedef GtkRecentChooserMenu BaseObjectType;
-  typedef GtkRecentChooserMenuClass BaseClassType;
-  typedef Gtk::Menu_Class CppClassParent;
-  typedef GtkMenuClass BaseClassParent;
-
-  friend class RecentChooserMenu;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_RECENTCHOOSERMENU_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/recentchooserwidget_p.h b/libs/gtkmm2/gtk/gtkmm/private/recentchooserwidget_p.h
deleted file mode 100644
index bc5746a026..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/recentchooserwidget_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSERWIDGET_P_H
-#define _GTKMM_RECENTCHOOSERWIDGET_P_H
-
-
-#include <gtkmm/private/box_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class RecentChooserWidget_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentChooserWidget CppObjectType;
-  typedef GtkRecentChooserWidget BaseObjectType;
-  typedef GtkRecentChooserWidgetClass BaseClassType;
-  typedef Gtk::VBox_Class CppClassParent;
-  typedef GtkVBoxClass BaseClassParent;
-
-  friend class RecentChooserWidget;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_RECENTCHOOSERWIDGET_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/recentfilter_p.h b/libs/gtkmm2/gtk/gtkmm/private/recentfilter_p.h
deleted file mode 100644
index 59292fe061..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/recentfilter_p.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTFILTER_P_H
-#define _GTKMM_RECENTFILTER_P_H
-
-
-#include <gtkmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class RecentFilter_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentFilter CppObjectType;
-  typedef GtkRecentFilter BaseObjectType;
-  typedef GtkRecentFilterClass BaseClassType;
-  typedef Gtk::Object_Class CppClassParent;
-  typedef GtkObjectClass BaseClassParent;
-
-  friend class RecentFilter;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_RECENTFILTER_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/recentinfo_p.h b/libs/gtkmm2/gtk/gtkmm/private/recentinfo_p.h
deleted file mode 100644
index 51acae2f92..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/recentinfo_p.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTINFO_P_H
-#define _GTKMM_RECENTINFO_P_H
-
-
-#endif /* _GTKMM_RECENTINFO_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/recentmanager_p.h b/libs/gtkmm2/gtk/gtkmm/private/recentmanager_p.h
deleted file mode 100644
index debc7cfbc7..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/recentmanager_p.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTMANAGER_P_H
-#define _GTKMM_RECENTMANAGER_P_H
-
-
-#include <glibmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class RecentManager_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentManager CppObjectType;
-  typedef GtkRecentManager BaseObjectType;
-  typedef GtkRecentManagerClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
-
-  friend class RecentManager;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 changed_callback(GtkRecentManager* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_RECENTMANAGER_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h b/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h
index 1d66f88aa5..9c44986646 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/ruler_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_RULER_P_H
 #define _GTKMM_RULER_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,17 +30,13 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void draw_ticks_vfunc_callback(GtkRuler* self);
   static void draw_pos_vfunc_callback(GtkRuler* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -75,15 +69,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -116,20 +106,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_RULER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/scale_p.h b/libs/gtkmm2/gtk/gtkmm/private/scale_p.h
index 65f2e920cc..aa5dddf050 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/scale_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/scale_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SCALE_P_H
 #define _GTKMM_SCALE_P_H
-
-
 #include <gtkmm/private/range_p.h>
 
 #include <glibmm/class.h>
@@ -32,17 +30,13 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 gchar* format_value_callback(GtkScale* self, gdouble p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void draw_value_vfunc_callback(GtkScale* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -75,15 +69,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -116,20 +106,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SCALE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h
index 9f0e9c9564..4781e3f466 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/scrollbar_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SCROLLBAR_P_H
 #define _GTKMM_SCROLLBAR_P_H
-
-
 #include <gtkmm/private/range_p.h>
 
 #include <glibmm/class.h>
@@ -32,15 +30,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -73,15 +67,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -114,20 +104,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SCROLLBAR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h b/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h
index d66d234b50..f66dde8f03 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/scrolledwindow_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SCROLLEDWINDOW_P_H
 #define _GTKMM_SCROLLEDWINDOW_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SCROLLEDWINDOW_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h b/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h
index 0bd23e9909..cb52061df2 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/selectiondata_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SELECTIONDATA_P_H
 #define _GTKMM_SELECTIONDATA_P_H
-
-
 #endif /* _GTKMM_SELECTIONDATA_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/separator_p.h b/libs/gtkmm2/gtk/gtkmm/private/separator_p.h
index c6d996a891..a82c02557d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/separator_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/separator_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SEPARATOR_P_H
 #define _GTKMM_SEPARATOR_P_H
-
-
 #include <gtkmm/private/widget_p.h>
 
 #include <glibmm/class.h>
@@ -32,15 +30,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -73,15 +67,11 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -114,20 +104,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SEPARATOR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h
index c8179813fc..1987425009 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/separatormenuitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SEPARATORMENUITEM_P_H
 #define _GTKMM_SEPARATORMENUITEM_P_H
-
-
 #include <gtkmm/private/menuitem_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SEPARATORMENUITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h
index 10ffaf4f16..5de5fc7e88 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/separatortoolitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SEPARATORTOOLITEM_P_H
 #define _GTKMM_SEPARATORTOOLITEM_P_H
-
-
 #include <gtkmm/private/toolitem_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SEPARATORTOOLITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/settings_p.h b/libs/gtkmm2/gtk/gtkmm/private/settings_p.h
index 88a999a636..72e13b447a 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/settings_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/settings_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SETTINGS_P_H
 #define _GTKMM_SETTINGS_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SETTINGS_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h b/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h
index 0be9253e4f..f33b8bdf58 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/sizegroup_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SIZEGROUP_P_H
 #define _GTKMM_SIZEGROUP_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SIZEGROUP_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/socket_p.h b/libs/gtkmm2/gtk/gtkmm/private/socket_p.h
index 7ca7f82aab..5689897e40 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/socket_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/socket_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SOCKET_P_H
 #define _GTKMM_SOCKET_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 plug_added_callback(GtkSocket* self);
   static gboolean plug_removed_callback(GtkSocket* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SOCKET_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h
index 8c1fd3d490..f69aee70cf 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/spinbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_SPINBUTTON_P_H
 #define _GTKMM_SPINBUTTON_P_H
-
-
 #include <gtkmm/private/entry_p.h>
 
 #include <glibmm/class.h>
@@ -32,23 +30,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 gint input_callback(GtkSpinButton* self, double* p0);
+  static gint input_callback(GtkSpinButton* self, gdouble* p0);
   static gboolean output_callback(GtkSpinButton* self);
   static void value_changed_callback(GtkSpinButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_SPINBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h
index 5dfb2fedb4..23efc95695 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/statusbar_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_STATUSBAR_P_H
 #define _GTKMM_STATUSBAR_P_H
-
-
 #include <gtkmm/private/box_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 text_pushed_callback(GtkStatusbar* self, guint p0, const gchar* p1);
   static void text_popped_callback(GtkStatusbar* self, guint p0, const gchar* p1);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_STATUSBAR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/statusicon_p.h b/libs/gtkmm2/gtk/gtkmm/private/statusicon_p.h
deleted file mode 100644
index bf396fbefe..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/private/statusicon_p.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_STATUSICON_P_H
-#define _GTKMM_STATUSICON_P_H
-
-
-#include <glibmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gtk
-{
-
-class StatusIcon_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef StatusIcon CppObjectType;
-  typedef GtkStatusIcon BaseObjectType;
-  typedef GtkStatusIconClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
-
-  friend class StatusIcon;
-#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:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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 size_changed_callback(GtkStatusIcon* self, gint p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Gtk
-
-
-#endif /* _GTKMM_STATUSICON_P_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h
index 7186456f86..0ac19c3f37 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/stockitem_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_STOCKITEM_P_H
 #define _GTKMM_STOCKITEM_P_H
-
-
 #endif /* _GTKMM_STOCKITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/style_p.h b/libs/gtkmm2/gtk/gtkmm/private/style_p.h
index ffa0a49806..8c10fca392 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/style_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/style_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_STYLE_P_H
 #define _GTKMM_STYLE_P_H
-
-
 #include <glibmm/private/object_p.h>
 #include <gtk/gtkrc.h>
 
@@ -33,16 +31,13 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 realize_callback(GtkStyle* self);
   static void unrealize_callback(GtkStyle* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void realize_vfunc_callback(GtkStyle* self);
   static void unrealize_vfunc_callback(GtkStyle* self);
   static void copy_vfunc_callback(GtkStyle* self, GtkStyle* src);
@@ -71,12 +66,10 @@ protected:
   static void draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, GtkExpanderStyle expander_style);
   static void draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, gboolean use_text, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, PangoLayout* layout);
   static void draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkWindowEdge edge, gint x, gint y, gint width, gint height);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_STYLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/table_p.h b/libs/gtkmm2/gtk/gtkmm/private/table_p.h
index 12d47b4091..8fae19b7cf 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/table_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/table_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TABLE_P_H
 #define _GTKMM_TABLE_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TABLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h b/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h
index 1d3d041c07..508f488cfd 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/targetlist_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TARGETLIST_P_H
 #define _GTKMM_TARGETLIST_P_H
-
-
 #endif /* _GTKMM_TARGETLIST_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h
index b3c479cc76..e6378ac638 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/tearoffmenuitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEAROFFMENUITEM_P_H
 #define _GTKMM_TEAROFFMENUITEM_P_H
-
-
 #include <gtkmm/private/menuitem_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TEAROFFMENUITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h b/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h
index 462c8fedf3..4b922c4c44 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/textattributes_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTATTRIBUTES_P_H
 #define _GTKMM_TEXTATTRIBUTES_P_H
-
-
 #endif /* _GTKMM_TEXTATTRIBUTES_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h b/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h
index 71dc9afc7c..59db070205 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/textbuffer_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTBUFFER_P_H
 #define _GTKMM_TEXTBUFFER_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -48,16 +45,12 @@ protected:
   static void remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2);
   static void begin_user_action_callback(GtkTextBuffer* self);
   static void end_user_action_callback(GtkTextBuffer* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TEXTBUFFER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h b/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h
index 4073dac2a2..a3a9822c45 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/textchildanchor_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTCHILDANCHOR_P_H
 #define _GTKMM_TEXTCHILDANCHOR_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TEXTCHILDANCHOR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h b/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h
index 591f3c94c5..b234c358b0 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/textiter_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTITER_P_H
 #define _GTKMM_TEXTITER_P_H
-
-
 #endif /* _GTKMM_TEXTITER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h b/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h
index 4841e5a2c0..bba46d8c62 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/textmark_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTMARK_P_H
 #define _GTKMM_TEXTMARK_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TEXTMARK_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h b/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h
index 9a3613fcd0..8cab5dac5b 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/texttag_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTTAG_P_H
 #define _GTKMM_TEXTTAG_P_H
-
-
 #include <glibmm/private/object_p.h>
 #include <gtk/gtktexttag.h>
 
@@ -33,21 +31,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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(GtkTextTag* self, GObject* p0, GdkEvent* p1, const GtkTextIter* p2);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TEXTTAG_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h b/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h
index 822d486a63..19964742d5 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/texttagtable_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTTAGTABLE_P_H
 #define _GTKMM_TEXTTAGTABLE_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,23 +30,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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(GtkTextTagTable* self, GtkTextTag* p0, gboolean p1);
   static void tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0);
   static void tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TEXTTAGTABLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/textview_p.h b/libs/gtkmm2/gtk/gtkmm/private/textview_p.h
index 3ffd102f02..328d08f8d2 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/textview_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/textview_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TEXTVIEW_P_H
 #define _GTKMM_TEXTVIEW_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -40,16 +37,12 @@ protected:
   static void populate_popup_callback(GtkTextView* self, GtkMenu* p0);
   static void set_anchor_callback(GtkTextView* self);
   static void insert_at_cursor_callback(GtkTextView* self, const gchar* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TEXTVIEW_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h b/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h
index 15e741f172..61de249561 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/toggleaction_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TOGGLEACTION_P_H
 #define _GTKMM_TOGGLEACTION_P_H
-
-
 #include <gtkmm/private/action_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 toggled_callback(GtkToggleAction* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TOGGLEACTION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h
index ea6cf01afd..73b571158f 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/togglebutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TOGGLEBUTTON_P_H
 #define _GTKMM_TOGGLEBUTTON_P_H
-
-
 #include <gtkmm/private/button_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 toggled_callback(GtkToggleButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TOGGLEBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h
index 7e0365630e..9ed1cd4da0 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/toggletoolbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TOGGLETOOLBUTTON_P_H
 #define _GTKMM_TOGGLETOOLBUTTON_P_H
-
-
 #include <gtkmm/private/toolbutton_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 toggled_callback(GtkToggleToolButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TOGGLETOOLBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h
index 87312f849e..f2bb20e0d3 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/toolbar_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TOOLBAR_P_H
 #define _GTKMM_TOOLBAR_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,23 +30,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 orientation_changed_callback(GtkToolbar* self, GtkOrientation p0);
   static void style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0);
   static gboolean popup_context_menu_callback(GtkToolbar* self, gint p0, gint p1, gint p2);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TOOLBAR_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h
index 57798065fc..2cac2dda6b 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/toolbutton_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TOOLBUTTON_P_H
 #define _GTKMM_TOOLBUTTON_P_H
-
-
 #include <gtkmm/private/toolitem_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 clicked_callback(GtkToolButton* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TOOLBUTTON_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h b/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h
index 715a50f04d..a35fb73560 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/toolitem_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TOOLITEM_P_H
 #define _GTKMM_TOOLITEM_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 create_menu_proxy_callback(GtkToolItem* self);
   static void toolbar_reconfigured_callback(GtkToolItem* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TOOLITEM_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h b/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h
index f59792fdf8..1872000504 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/tooltips_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TOOLTIPS_P_H
 #define _GTKMM_TOOLTIPS_P_H
-
-
 #include <gtkmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TOOLTIPS_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h b/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h
index b8eb6b4268..0486146e02 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treedragdest_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEDRAGDEST_P_H
 #define _GTKMM_TREEDRAGDEST_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,22 +27,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gboolean drag_data_received_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest, GtkSelectionData* selection_data);
   static gboolean row_drop_possible_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest_path, GtkSelectionData* selection_data);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREEDRAGDEST_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h b/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h
index 9474f71661..07f02f964f 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treedragsource_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEDRAGSOURCE_P_H
 #define _GTKMM_TREEDRAGSOURCE_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,23 +27,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
     static gboolean drag_data_get_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path, GtkSelectionData* selection_data);
     static gboolean row_draggable_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path);
   static gboolean drag_data_delete_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREEDRAGSOURCE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h
index 0dc21a4a87..bc45469e97 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeiter_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEITER_P_H
 #define _GTKMM_TREEITER_P_H
-
-
 #endif /* _GTKMM_TREEITER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h
index 7737ebfbdd..401d707834 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treemodel_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEMODEL_P_H
 #define _GTKMM_TREEMODEL_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,7 +27,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -38,10 +35,8 @@ protected:
   static void row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter);
   static void row_deleted_callback(GtkTreeModel* self, GtkTreePath* path);
   static void rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter, gint* new_order);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static GtkTreeModelFlags get_flags_vfunc_callback(GtkTreeModel* self);
   static gint get_n_columns_vfunc_callback(GtkTreeModel* self);
   static GType get_column_type_vfunc_callback(GtkTreeModel* self, gint index);
@@ -56,12 +51,10 @@ protected:
   static void unref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
   static GtkTreePath* get_path_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter);
   static void get_value_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, gint column, GValue* value);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREEMODEL_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h
index ced499eaab..cd4f27a229 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treemodelfilter_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEMODELFILTER_P_H
 #define _GTKMM_TREEMODELFILTER_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREEMODELFILTER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h b/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h
index 80becc6980..ce050925cb 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treemodelsort_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEMODELSORT_P_H
 #define _GTKMM_TREEMODELSORT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREEMODELSORT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h b/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h
index 8381046439..829820cfe5 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treepath_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEPATH_P_H
 #define _GTKMM_TREEPATH_P_H
-
-
 #endif /* _GTKMM_TREEPATH_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h b/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h
index 44aa245259..00bcc4b2fe 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treerowreference_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEROWREFERENCE_P_H
 #define _GTKMM_TREEROWREFERENCE_P_H
-
-
 #endif /* _GTKMM_TREEROWREFERENCE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h
index dbe93b4891..ee7fcce1e7 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeselection_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREESELECTION_P_H
 #define _GTKMM_TREESELECTION_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 changed_callback(GtkTreeSelection* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREESELECTION_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h b/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h
index 82305bb6d0..f93f94c10d 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treesortable_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREESORTABLE_P_H
 #define _GTKMM_TREESORTABLE_P_H
-
-
 #include <glibmm/private/interface_p.h>
 
 #include <glibmm/private/interface_p.h>
@@ -29,27 +27,22 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 sort_column_changed_callback(GtkTreeSortable* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static gboolean get_sort_column_id_vfunc_callback(GtkTreeSortable* self, int* sort_column_id, GtkSortType* order);
   static void set_sort_column_id_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkSortType order);
   static void set_sort_func_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy);
   static void set_default_sort_func_vfunc_callback(GtkTreeSortable* self, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy);
   static gboolean has_default_sort_func_vfunc_callback(GtkTreeSortable* self);
   static void sort_column_changed_vfunc_callback(GtkTreeSortable* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREESORTABLE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h b/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h
index a18b3166e2..fb1c7bc681 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treestore_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREESTORE_P_H
 #define _GTKMM_TREESTORE_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREESTORE_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h
index b2b4668e69..127465f857 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeview_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEVIEW_P_H
 #define _GTKMM_TREEVIEW_P_H
-
-
 #include <gtkmm/private/container_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -44,16 +41,12 @@ protected:
   static void row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1);
   static void cursor_changed_callback(GtkTreeView* self);
   static void columns_changed_callback(GtkTreeView* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREEVIEW_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h b/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h
index 7d3a975e4d..f47a4a3279 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/treeviewcolumn_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_TREEVIEWCOLUMN_P_H
 #define _GTKMM_TREEVIEWCOLUMN_P_H
-
-
 #include <gtkmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 clicked_callback(GtkTreeViewColumn* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_TREEVIEWCOLUMN_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h b/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h
index ab4d67bb9c..6932d4f791 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/uimanager_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_UIMANAGER_P_H
 #define _GTKMM_UIMANAGER_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,22 +30,17 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 add_widget_callback(GtkUIManager* self, GtkWidget* p0);
   static void actions_changed_callback(GtkUIManager* self);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_UIMANAGER_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h b/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h
index e6178502da..18fce1d06c 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/viewport_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_VIEWPORT_P_H
 #define _GTKMM_VIEWPORT_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -32,21 +30,16 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0, GtkAdjustment* p1);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_VIEWPORT_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/widget_p.h b/libs/gtkmm2/gtk/gtkmm/private/widget_p.h
index cbcb16d1a7..ce8df67d36 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/widget_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/widget_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_WIDGET_P_H
 #define _GTKMM_WIDGET_P_H
-
-
 #include <gtkmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,7 +30,6 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
@@ -90,31 +87,21 @@ protected:
   static gboolean drag_motion_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3);
   static gboolean drag_drop_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3);
   static void drag_data_received_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, GtkSelectionData* p3, guint p4, guint p5);
-#ifdef GTKMM_ATKMM_ENABLED
   static AtkObject* get_accessible_callback(GtkWidget* self);
-#endif // GTKMM_ATKMM_ENABLED
   static void screen_changed_callback(GtkWidget* self, GdkScreen* p0);
     static void hierarchy_changed_callback_custom(GtkWidget* self, GtkWidget* p0);
       static void parent_set_callback_custom(GtkWidget* self, GtkWidget* p0);
-  #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
+  
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED //We always need dispose_vfunc_callback
     static void dispose_vfunc_callback(GObject* self);
-#ifdef GLIBMM_VFUNCS_ENABLED
     static void dispatch_child_properties_changed_vfunc_callback(GtkWidget* self, guint n_pspecs, GParamSpec** pspecs);
   static void show_all_vfunc_callback(GtkWidget* self);
   static void hide_all_vfunc_callback(GtkWidget* self);
-#ifdef GTKMM_ATKMM_ENABLED
   static AtkObject* get_accessible_vfunc_callback(GtkWidget* self);
-#endif // GTKMM_ATKMM_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_WIDGET_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/private/window_p.h b/libs/gtkmm2/gtk/gtkmm/private/window_p.h
index 381c247f01..5413a7284a 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/window_p.h
+++ b/libs/gtkmm2/gtk/gtkmm/private/window_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _GTKMM_WINDOW_P_H
 #define _GTKMM_WINDOW_P_H
-
-
 #include <gtkmm/private/bin_p.h>
 
 #include <glibmm/class.h>
@@ -11,17 +9,17 @@
 namespace Gtk
 {
 
-class WindowGroup_Class : public Glib::Class
+class Window_Class : public Glib::Class
 {
 public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef WindowGroup CppObjectType;
-  typedef GtkWindowGroup BaseObjectType;
-  typedef GtkWindowGroupClass BaseClassType;
-  typedef Glib::Object_Class CppClassParent;
-  typedef GObjectClass BaseClassParent;
+  typedef Window CppObjectType;
+  typedef GtkWindow BaseObjectType;
+  typedef GtkWindowClass BaseClassType;
+  typedef Gtk::Bin_Class CppClassParent;
+  typedef GtkBinClass BaseClassParent;
 
-  friend class WindowGroup;
+  friend class Window;
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
   const Glib::Class& init();
@@ -32,16 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+  static void set_focus_callback(GtkWindow* self, GtkWidget* p0);
+  static gboolean frame_event_callback(GtkWindow* self, GdkEvent* p0);
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
+    static void dispose_vfunc_callback(GObject* self);
+  };
 
 
 } // namespace Gtk
@@ -52,17 +49,17 @@ protected:
 namespace Gtk
 {
 
-class Window_Class : public Glib::Class
+class WindowGroup_Class : public Glib::Class
 {
 public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef Window CppObjectType;
-  typedef GtkWindow BaseObjectType;
-  typedef GtkWindowClass BaseClassType;
-  typedef Gtk::Bin_Class CppClassParent;
-  typedef GtkBinClass BaseClassParent;
+  typedef WindowGroup CppObjectType;
+  typedef GtkWindowGroup BaseObjectType;
+  typedef GtkWindowGroupClass BaseClassType;
+  typedef Glib::Object_Class CppClassParent;
+  typedef GObjectClass BaseClassParent;
 
-  friend class Window;
+  friend class WindowGroup;
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
   const Glib::Class& init();
@@ -73,25 +70,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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 set_focus_callback(GtkWindow* self, GtkWidget* p0);
-  static gboolean frame_event_callback(GtkWindow* self, GdkEvent* p0);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED //We always need dispose_vfunc_callback
-    static void dispose_vfunc_callback(GObject* self);
-#ifdef GLIBMM_VFUNCS_ENABLED
-  #endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Gtk
 
-
 #endif /* _GTKMM_WINDOW_P_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/progressbar.cc b/libs/gtkmm2/gtk/gtkmm/progressbar.cc
index e5ec87dfea..fb515e88ad 100644
--- a/libs/gtkmm2/gtk/gtkmm/progressbar.cc
+++ b/libs/gtkmm2/gtk/gtkmm/progressbar.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/progressbar.h>
 #include <gtkmm/private/progressbar_p.h>
 
@@ -30,6 +29,7 @@
 #include <gtkmm/adjustment.h>
 #include <gtk/gtkprogressbar.h>
 
+
 namespace
 {
 } // anonymous namespace
@@ -88,19 +88,8 @@ void ProgressBar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ProgressBar_Class::wrap_new(GObject* o)
 {
@@ -150,7 +139,7 @@ ProgressBar::ProgressBar()
 
 void ProgressBar::pulse()
 {
-gtk_progress_bar_pulse(gobj()); 
+  gtk_progress_bar_pulse(gobj());
 }
 
 Glib::ustring ProgressBar::get_text() const
@@ -160,7 +149,7 @@ Glib::ustring ProgressBar::get_text() const
 
 void ProgressBar::set_text(const Glib::ustring& text)
 {
-gtk_progress_bar_set_text(gobj(), text.c_str()); 
+  gtk_progress_bar_set_text(gobj(), text.c_str());
 }
 
 double ProgressBar::get_fraction() const
@@ -170,7 +159,7 @@ double ProgressBar::get_fraction() const
 
 void ProgressBar::set_fraction(double fraction)
 {
-gtk_progress_bar_set_fraction(gobj(), fraction); 
+  gtk_progress_bar_set_fraction(gobj(), fraction);
 }
 
 double ProgressBar::get_pulse_step() const
@@ -180,12 +169,12 @@ double ProgressBar::get_pulse_step() const
 
 void ProgressBar::set_pulse_step(double fraction)
 {
-gtk_progress_bar_set_pulse_step(gobj(), fraction); 
+  gtk_progress_bar_set_pulse_step(gobj(), fraction);
 }
 
 void ProgressBar::set_orientation(ProgressBarOrientation orientation)
 {
-gtk_progress_bar_set_orientation(gobj(), ((GtkProgressBarOrientation)(orientation))); 
+  gtk_progress_bar_set_orientation(gobj(), ((GtkProgressBarOrientation)(orientation)));
 }
 
 ProgressBarOrientation ProgressBar::get_orientation() const
@@ -195,7 +184,7 @@ ProgressBarOrientation ProgressBar::get_orientation() const
 
 void ProgressBar::set_ellipsize(Pango::EllipsizeMode mode)
 {
-gtk_progress_bar_set_ellipsize(gobj(), ((PangoEllipsizeMode)(mode))); 
+  gtk_progress_bar_set_ellipsize(gobj(), ((PangoEllipsizeMode)(mode)));
 }
 
 Pango::EllipsizeMode ProgressBar::get_ellipsize() const
@@ -204,82 +193,55 @@ Pango::EllipsizeMode ProgressBar::get_ellipsize() const
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> ProgressBar::property_fraction() 
 {
   return Glib::PropertyProxy<double>(this, "fraction");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> ProgressBar::property_fraction() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "fraction");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> ProgressBar::property_pulse_step() 
 {
   return Glib::PropertyProxy<double>(this, "pulse-step");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> ProgressBar::property_pulse_step() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "pulse-step");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ProgressBarOrientation> ProgressBar::property_orientation() 
 {
   return Glib::PropertyProxy<ProgressBarOrientation>(this, "orientation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ProgressBarOrientation> ProgressBar::property_orientation() const
 {
   return Glib::PropertyProxy_ReadOnly<ProgressBarOrientation>(this, "orientation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> ProgressBar::property_text() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> ProgressBar::property_text() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ProgressBar::property_ellipsize() 
 {
   return Glib::PropertyProxy<bool>(this, "ellipsize");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ProgressBar::property_ellipsize() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "ellipsize");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/progressbar.h b/libs/gtkmm2/gtk/gtkmm/progressbar.h
index 1a2401a63e..d79db97633 100644
--- a/libs/gtkmm2/gtk/gtkmm/progressbar.h
+++ b/libs/gtkmm2/gtk/gtkmm/progressbar.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_PROGRESSBAR_H
 #define _GTKMM_PROGRESSBAR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -178,17 +177,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -208,8 +201,11 @@ public:
 
   
   /** Retrieves the text displayed superimposed on the progress bar,
-   * if any.
-   * @return Text.
+   * if any, otherwise <tt>0</tt>. The return value is a reference
+   * to the text, not a copy of it, so will become invalid
+   * if you change the text in the progress bar.
+   * @return Text, or <tt>0</tt>; this string is owned by the widget
+   * and should not be modified or freed.
    */
   Glib::ustring get_text() const;
   
@@ -259,30 +255,21 @@ public:
   /** Sets the mode used to ellipsize (add an ellipsis: "...") the text 
    * if there is not enough space to render the entire string.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param mode A Pango::EllipsizeMode.
    */
   void set_ellipsize(Pango::EllipsizeMode mode);
   
-  /** Returns the ellipsizing position of the progressbar. 
-   * See set_ellipsize().
-   * @return Pango::EllipsizeMode
-   * 
-   * @newin2p6.
-   */
   Pango::EllipsizeMode get_ellipsize() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The fraction of total work that has been completed.
+  /** The fraction of total work that has been completed.
    *
    * 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_fraction() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The fraction of total work that has been completed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -290,19 +277,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_fraction() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The fraction of total progress to move the bouncing block when pulsed.
+  /** The fraction of total progress to move the bouncing block when pulsed.
    *
    * 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_pulse_step() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The fraction of total progress to move the bouncing block when pulsed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -310,19 +293,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_pulse_step() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Orientation and growth direction of the progress bar.
+  /** Orientation and growth direction of the progress bar.
    *
    * 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<ProgressBarOrientation> property_orientation() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Orientation and growth direction of the progress bar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -330,19 +309,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ProgressBarOrientation> property_orientation() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text to be displayed in the progress bar.
+  /** Text to be displayed in the progress bar.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text to be displayed in the progress bar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -350,19 +325,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_text() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The preferred place to ellipsize the string
+  /** The preferred place to ellipsize the string
    *
    * 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_ellipsize() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The preferred place to ellipsize the string
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -370,7 +341,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_ellipsize() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -386,8 +356,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ProgressBar* wrap(GtkProgressBar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_PROGRESSBAR_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/radioaction.cc b/libs/gtkmm2/gtk/gtkmm/radioaction.cc
index 8d20b23fe6..bac64f9dc4 100644
--- a/libs/gtkmm2/gtk/gtkmm/radioaction.cc
+++ b/libs/gtkmm2/gtk/gtkmm/radioaction.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/radioaction.h>
 #include <gtkmm/private/radioaction_p.h>
 
@@ -65,8 +64,7 @@ void RadioAction::set_group(Group& group)
 namespace
 {
 
-
-static void RadioAction_signal_changed_callback(GtkRadioAction* self, GtkRadioAction* p0,void* data)
+void RadioAction_signal_changed_callback(GtkRadioAction* self, GtkRadioAction* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<RadioAction>& > SlotType;
@@ -74,31 +72,26 @@ static void RadioAction_signal_changed_callback(GtkRadioAction* self, GtkRadioAc
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo RadioAction_signal_changed_info =
+const Glib::SignalProxyInfo RadioAction_signal_changed_info =
 {
   "changed",
   (GCallback) &RadioAction_signal_changed_callback,
   (GCallback) &RadioAction_signal_changed_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -145,18 +138,10 @@ void RadioAction_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->changed = &changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void RadioAction_Class::changed_callback(GtkRadioAction* self, GtkRadioAction* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -169,20 +154,16 @@ void RadioAction_Class::changed_callback(GtkRadioAction* self, GtkRadioAction* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -195,7 +176,6 @@ void RadioAction_Class::changed_callback(GtkRadioAction* self, GtkRadioAction* p
       (*base->changed)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* RadioAction_Class::wrap_new(GObject* object)
@@ -260,11 +240,6 @@ int RadioAction::get_current_value() const
   return gtk_radio_action_get_current_value(const_cast<GtkRadioAction*>(gobj()));
 }
 
-void RadioAction::set_current_value(int current_value)
-{
-gtk_radio_action_set_current_value(gobj(), current_value); 
-}
-
 
 Glib::SignalProxy1< void,const Glib::RefPtr<RadioAction>& > RadioAction::signal_changed()
 {
@@ -272,36 +247,17 @@ Glib::SignalProxy1< void,const Glib::RefPtr<RadioAction>& > RadioAction::signal_
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> RadioAction::property_value() 
 {
   return Glib::PropertyProxy<int>(this, "value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> RadioAction::property_value() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> RadioAction::property_current_value() 
-{
-  return Glib::PropertyProxy<int>(this, "current-value");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> RadioAction::property_current_value() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "current-value");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::RadioAction::on_changed(const Glib::RefPtr<RadioAction>& current)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -311,10 +267,6 @@ void Gtk::RadioAction::on_changed(const Glib::RefPtr<RadioAction>& current)
   if(base && base->changed)
     (*base->changed)(gobj(),Glib::unwrap(current));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/radioaction.h b/libs/gtkmm2/gtk/gtkmm/radioaction.h
index 20673cf1de..7c4366c123 100644
--- a/libs/gtkmm2/gtk/gtkmm/radioaction.h
+++ b/libs/gtkmm2/gtk/gtkmm/radioaction.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_RADIOACTION_H
 #define _GTKMM_RADIOACTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -100,67 +99,35 @@ public:
   static Glib::RefPtr<RadioAction> create(Group& group, const Glib::ustring& name, const Gtk::StockID& stock_id, const Glib::ustring& label = Glib::ustring(), const Glib::ustring& tooltip =  Glib::ustring());
 
   
-  /** Returns the list representing the radio group for this object.
-   * Note that the returned list is only valid until the next change
-   * to the group. 
-   * 
-   * A common way to set up a group of radio group is the following:
-   * @code
-   * GSList *group = <tt>0</tt>;
-   * GtkRadioAction *action;
-   * 
-   * while (/&lt;!-- --&gt;* more actions to add *&lt;!-- --&gt;/)
-   * {
-   * action = gtk_radio_action_new (...);
-   * 
-   * gtk_radio_action_set_group (action, group);
-   * group = gtk_radio_action_get_group (action);
-   * }
-   * @endcode
+  /** Returns the list representing the radio group for this object
    * @return The list representing the radio group for this object
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Group get_group();
    void set_group(Group& group);
   
   
-  /** Obtains the value property of the currently active member of 
+  /** Obtains the value property of the the currently active member of 
    * the group to which @a action  belongs.
    * @return The value of the currently active group member
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_current_value() const;
-  
-  void set_current_value(int current_value);
 
-  /** The changed signal is emitted on every member of a radio group when the
-   * active member is changed. The signal is emitted after the activate signals
-   * for the previous and current active members.
-   *
-   * @param current the member of this action's group which has just been activated.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %changed(const Glib::RefPtr<RadioAction>& current)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<RadioAction>& > signal_changed();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The value returned by gtk_radio_action_get_current_value when this action is the current action of its group.
+  /** The value returned by gtk_radio_action_get_current_value when this action is the current action of its 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<int> property_value() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The value returned by gtk_radio_action_get_current_value when this action is the current action of its group.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -168,45 +135,18 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_value() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The value property of the currently active member of the group to which this action belongs.
-   *
-   * 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_current_value() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The value property of the currently active member of the group to which this action belongs.
-   *
-   * 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_current_value() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_changed(const Glib::RefPtr<RadioAction>& current);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/radiobutton.cc b/libs/gtkmm2/gtk/gtkmm/radiobutton.cc
index 6883e36fd8..6fb1b2985f 100644
--- a/libs/gtkmm2/gtk/gtkmm/radiobutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/radiobutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/radiobutton.h>
 #include <gtkmm/private/radiobutton_p.h>
 
@@ -80,15 +79,13 @@ void RadioButton::reset_group()
 namespace
 {
 
-
-static const Glib::SignalProxyInfo RadioButton_signal_group_changed_info =
+const Glib::SignalProxyInfo RadioButton_signal_group_changed_info =
 {
   "group_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -133,18 +130,10 @@ void RadioButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->group_changed = &group_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void RadioButton_Class::group_changed_callback(GtkRadioButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -157,19 +146,15 @@ void RadioButton_Class::group_changed_callback(GtkRadioButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_group_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -182,7 +167,6 @@ void RadioButton_Class::group_changed_callback(GtkRadioButton* self)
       (*base->group_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* RadioButton_Class::wrap_new(GObject* o)
@@ -236,7 +220,6 @@ Glib::SignalProxy0< void > RadioButton::signal_group_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::RadioButton::on_group_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -246,10 +229,6 @@ void Gtk::RadioButton::on_group_changed()
   if(base && base->group_changed)
     (*base->group_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/radiobutton.h b/libs/gtkmm2/gtk/gtkmm/radiobutton.h
index 19d5ae323f..f81a6e624f 100644
--- a/libs/gtkmm2/gtk/gtkmm/radiobutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/radiobutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_RADIOBUTTON_H
 #define _GTKMM_RADIOBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -93,18 +92,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_group_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -132,31 +125,11 @@ public:
   RadioButton(Group& group, const Glib::ustring& label, bool mnemonic = false);
   
 
-  /** Get the radio button's group.
-   * This group may be passed to the constructors of other radio buttons, or used with set_group().
-   *
-   * @result The group to which the radio button belongs.
-   */
-  
   Group get_group();
-
- /** Set the radio button's group.
-   * You can obtain a suitable group from another radio button by using get_group().
-   *
-   * @result The group to which the radio button should belong.
-   */
   void set_group(Group& group);
-
-  /** Remove the radio button from the group.
-   */
   void reset_group();
   
 
-/**
-   * @par Prototype:
-   * <tt>void %group_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_group_changed();
 
 
@@ -173,8 +146,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::RadioButton* wrap(GtkRadioButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_RADIOBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/radiomenuitem.cc b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.cc
index ecbbd8ca96..15bff44cc2 100644
--- a/libs/gtkmm2/gtk/gtkmm/radiomenuitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/radiomenuitem.h>
 #include <gtkmm/private/radiomenuitem_p.h>
 
@@ -72,15 +71,13 @@ void RadioMenuItem::reset_group()
 namespace
 {
 
-
-static const Glib::SignalProxyInfo RadioMenuItem_signal_group_changed_info =
+const Glib::SignalProxyInfo RadioMenuItem_signal_group_changed_info =
 {
   "group_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -125,18 +122,10 @@ void RadioMenuItem_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->group_changed = &group_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void RadioMenuItem_Class::group_changed_callback(GtkRadioMenuItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -149,19 +138,15 @@ void RadioMenuItem_Class::group_changed_callback(GtkRadioMenuItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_group_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -174,7 +159,6 @@ void RadioMenuItem_Class::group_changed_callback(GtkRadioMenuItem* self)
       (*base->group_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* RadioMenuItem_Class::wrap_new(GObject* o)
@@ -228,7 +212,6 @@ Glib::SignalProxy0< void > RadioMenuItem::signal_group_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::RadioMenuItem::on_group_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -238,10 +221,6 @@ void Gtk::RadioMenuItem::on_group_changed()
   if(base && base->group_changed)
     (*base->group_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/radiomenuitem.h b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.h
index c8ea9078c0..364a088131 100644
--- a/libs/gtkmm2/gtk/gtkmm/radiomenuitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/radiomenuitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_RADIOMENUITEM_H
 #define _GTKMM_RADIOMENUITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -93,18 +92,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_group_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -126,19 +119,7 @@ public:
   void set_group(Group& group);
   void reset_group();
 
-  /** Emitted when the group of radio menu items that a radio menu item belongs
-   * to changes. This is emitted when a radio menu item switches from
-   * being alone to being part of a group of 2 or more menu items, or
-   * vice-versa, and when a buttton is moved from one group of 2 or
-   * more menu items to a different one, but not when the composition
-   * of the group that a menu item belongs to changes.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %group_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_group_changed();
 
 
@@ -159,8 +140,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::RadioMenuItem* wrap(GtkRadioMenuItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_RADIOMENUITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.cc b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.cc
index 24c358810e..19f716a33b 100644
--- a/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/radiotoolbutton.h>
 #include <gtkmm/private/radiotoolbutton_p.h>
 
@@ -119,19 +118,8 @@ void RadioToolButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* RadioToolButton_Class::wrap_new(GObject* o)
 {
@@ -186,17 +174,10 @@ Group RadioToolButton::get_group()
 
 void RadioToolButton::set_group(Group& group)
 {
-gtk_radio_tool_button_set_group(gobj(), group.group_); 
+  gtk_radio_tool_button_set_group(gobj(), group.group_);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.h b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.h
index 38200eede3..02eec24f74 100644
--- a/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/radiotoolbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_RADIOTOOLBUTTON_H
 #define _GTKMM_RADIOTOOLBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -94,17 +93,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -118,7 +111,7 @@ public:
    * Use get_group() to retrieve this group and pass it to other radio buttons to assign
    * them to this group.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   RadioToolButton();
   
@@ -130,7 +123,7 @@ public:
    * @param group The existing group which will be used for this RadioButton.
    * @param label The string used to display the label for this RadioToolButton.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   explicit RadioToolButton(Group& group, const Glib::ustring& label = Glib::ustring());
   
@@ -143,7 +136,7 @@ public:
    * @param group The existing group which will be used for this RadioButton.
    * @param stock_id The StockID which determines the look of the RadioToolButton.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   RadioToolButton(Group& group, const Gtk::StockID& stock_id);
   
@@ -164,7 +157,7 @@ public:
    * @param icon_widget The widget placed as the RadioToolButton's icon.
    * @param label The string used to display the label for this RadioToolButton.
    *
-   * @newin2p4
+   * Since: 2.4
    */
   explicit RadioToolButton(Widget& icon_widget, const Glib::ustring& label = Glib::ustring());
 
@@ -172,13 +165,13 @@ public:
   /** Returns the radio button group @a button  belongs to.
    * @return The group @a button  belongs to.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Group get_group();
   
   /** Adds @a button  to @a group , removing it from the group it belonged to before.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param group An existing radio button group.
    */
   void set_group(Group& group);
@@ -197,8 +190,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::RadioToolButton* wrap(GtkRadioToolButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_RADIOTOOLBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/range.cc b/libs/gtkmm2/gtk/gtkmm/range.cc
index b6a1f2cf41..f7bf958b2e 100644
--- a/libs/gtkmm2/gtk/gtkmm/range.cc
+++ b/libs/gtkmm2/gtk/gtkmm/range.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/range.h>
 #include <gtkmm/private/range_p.h>
 
@@ -41,8 +40,7 @@ void Range::unset_adjustment()
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Range_signal_value_changed_info =
+const Glib::SignalProxyInfo Range_signal_value_changed_info =
 {
   "value_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -50,7 +48,7 @@ static const Glib::SignalProxyInfo Range_signal_value_changed_info =
 };
 
 
-static void Range_signal_adjust_bounds_callback(GtkRange* self, gdouble p0,void* data)
+void Range_signal_adjust_bounds_callback(GtkRange* self, gdouble p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,double > SlotType;
@@ -58,24 +56,20 @@ static void Range_signal_adjust_bounds_callback(GtkRange* self, gdouble p0,void*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Range_signal_adjust_bounds_info =
+const Glib::SignalProxyInfo Range_signal_adjust_bounds_info =
 {
   "adjust_bounds",
   (GCallback) &Range_signal_adjust_bounds_callback,
@@ -83,7 +77,7 @@ static const Glib::SignalProxyInfo Range_signal_adjust_bounds_info =
 };
 
 
-static void Range_signal_move_slider_callback(GtkRange* self, GtkScrollType p0,void* data)
+void Range_signal_move_slider_callback(GtkRange* self, GtkScrollType p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,ScrollType > SlotType;
@@ -91,24 +85,20 @@ static void Range_signal_move_slider_callback(GtkRange* self, GtkScrollType p0,v
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Range_signal_move_slider_info =
+const Glib::SignalProxyInfo Range_signal_move_slider_info =
 {
   "move_slider",
   (GCallback) &Range_signal_move_slider_callback,
@@ -116,7 +106,7 @@ static const Glib::SignalProxyInfo Range_signal_move_slider_info =
 };
 
 
-static gboolean Range_signal_change_value_callback(GtkRange* self, GtkScrollType p0,gdouble p1,void* data)
+gboolean Range_signal_change_value_callback(GtkRange* self, GtkScrollType p0,gdouble p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,ScrollType,double > SlotType;
@@ -124,28 +114,24 @@ static gboolean Range_signal_change_value_callback(GtkRange* self, GtkScrollType
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(((ScrollType)(p0))
 , p1
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Range_signal_change_value_notify_callback(GtkRange* self, GtkScrollType p0,gdouble p1, void* data)
+gboolean Range_signal_change_value_notify_callback(GtkRange* self, GtkScrollType p0,gdouble p1, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,ScrollType,double > SlotType;
@@ -153,43 +139,32 @@ static gboolean Range_signal_change_value_notify_callback(GtkRange* self, GtkScr
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((ScrollType)(p0))
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Range_signal_change_value_info =
+const Glib::SignalProxyInfo Range_signal_change_value_info =
 {
   "change_value",
   (GCallback) &Range_signal_change_value_callback,
   (GCallback) &Range_signal_change_value_notify_callback
 };
 
-
 } // anonymous namespace
 
-// static
-GType Glib::Value<Gtk::SensitivityType>::value_type()
-{
-  return gtk_sensitivity_type_get_type();
-}
-
 
 namespace Glib
 {
@@ -232,18 +207,12 @@ void Range_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_range_border = &get_range_border_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->value_changed = &value_changed_callback;
   klass->adjust_bounds = &adjust_bounds_callback;
   klass->move_slider = &move_slider_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Range_Class::get_range_border_vfunc_callback(GtkRange* self, GtkBorder* border)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -256,19 +225,15 @@ void Range_Class::get_range_border_vfunc_callback(GtkRange* self, GtkBorder* bor
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_range_border_vfunc(border);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -281,9 +246,8 @@ void Range_Class::get_range_border_vfunc_callback(GtkRange* self, GtkBorder* bor
       (*base->get_range_border)(self, border);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Range_Class::value_changed_callback(GtkRange* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -296,19 +260,15 @@ void Range_Class::value_changed_callback(GtkRange* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_value_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -321,6 +281,7 @@ void Range_Class::value_changed_callback(GtkRange* self)
       (*base->value_changed)(self);
   }
 }
+
 void Range_Class::adjust_bounds_callback(GtkRange* self, gdouble p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -333,20 +294,16 @@ void Range_Class::adjust_bounds_callback(GtkRange* self, gdouble p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_adjust_bounds(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -359,6 +316,7 @@ void Range_Class::adjust_bounds_callback(GtkRange* self, gdouble p0)
       (*base->adjust_bounds)(self, p0);
   }
 }
+
 void Range_Class::move_slider_callback(GtkRange* self, GtkScrollType p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -371,20 +329,16 @@ void Range_Class::move_slider_callback(GtkRange* self, GtkScrollType p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_move_slider(((ScrollType)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -397,7 +351,6 @@ void Range_Class::move_slider_callback(GtkRange* self, GtkScrollType p0)
       (*base->move_slider)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Range_Class::wrap_new(GObject* o)
@@ -448,7 +401,7 @@ Range::Range()
 
 void Range::set_update_policy(UpdateType policy)
 {
-gtk_range_set_update_policy(gobj(), ((GtkUpdateType)(policy))); 
+  gtk_range_set_update_policy(gobj(), ((GtkUpdateType)(policy)));
 }
 
 UpdateType Range::get_update_policy() const
@@ -458,7 +411,7 @@ UpdateType Range::get_update_policy() const
 
 void Range::set_adjustment(Gtk::Adjustment& adjustment)
 {
-gtk_range_set_adjustment(gobj(), (adjustment).gobj()); 
+  gtk_range_set_adjustment(gobj(), (adjustment).gobj());
 }
 
 Gtk::Adjustment* Range::get_adjustment()
@@ -468,12 +421,12 @@ Gtk::Adjustment* Range::get_adjustment()
 
 const Gtk::Adjustment* Range::get_adjustment() const
 {
-  return const_cast<Range*>(this)->get_adjustment();
+  return Glib::wrap(gtk_range_get_adjustment(const_cast<GtkRange*>(gobj())));
 }
 
 void Range::set_inverted(bool setting)
 {
-gtk_range_set_inverted(gobj(), static_cast<int>(setting)); 
+  gtk_range_set_inverted(gobj(), static_cast<int>(setting));
 }
 
 bool Range::get_inverted() const
@@ -481,39 +434,19 @@ bool Range::get_inverted() const
   return gtk_range_get_inverted(const_cast<GtkRange*>(gobj()));
 }
 
-void Range::set_lower_stepper_sensitivity(SensitivityType sensitivity)
-{
-gtk_range_set_lower_stepper_sensitivity(gobj(), ((GtkSensitivityType)(sensitivity))); 
-}
-
-SensitivityType Range::get_lower_stepper_sensitivity() const
-{
-  return ((SensitivityType)(gtk_range_get_lower_stepper_sensitivity(const_cast<GtkRange*>(gobj()))));
-}
-
-void Range::set_upper_stepper_sensitivity(SensitivityType sensitivity)
-{
-gtk_range_set_upper_stepper_sensitivity(gobj(), ((GtkSensitivityType)(sensitivity))); 
-}
-
-SensitivityType Range::get_upper_stepper_sensitivity() const
-{
-  return ((SensitivityType)(gtk_range_get_upper_stepper_sensitivity(const_cast<GtkRange*>(gobj()))));
-}
-
 void Range::set_increments(double step, double page)
 {
-gtk_range_set_increments(gobj(), step, page); 
+  gtk_range_set_increments(gobj(), step, page);
 }
 
 void Range::set_range(double min, double max)
 {
-gtk_range_set_range(gobj(), min, max); 
+  gtk_range_set_range(gobj(), min, max);
 }
 
 void Range::set_value(double value)
 {
-gtk_range_set_value(gobj(), value); 
+  gtk_range_set_value(gobj(), value);
 }
 
 double Range::get_value() const
@@ -527,97 +460,53 @@ Glib::SignalProxy0< void > Range::signal_value_changed()
   return Glib::SignalProxy0< void >(this, &Range_signal_value_changed_info);
 }
 
-
 Glib::SignalProxy1< void,double > Range::signal_adjust_bounds()
 {
   return Glib::SignalProxy1< void,double >(this, &Range_signal_adjust_bounds_info);
 }
 
-
 Glib::SignalProxy1< void,ScrollType > Range::signal_move_slider()
 {
   return Glib::SignalProxy1< void,ScrollType >(this, &Range_signal_move_slider_info);
 }
 
-
 Glib::SignalProxy2< bool,ScrollType,double > Range::signal_change_value()
 {
   return Glib::SignalProxy2< bool,ScrollType,double >(this, &Range_signal_change_value_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<UpdateType> Range::property_update_policy() 
 {
   return Glib::PropertyProxy<UpdateType>(this, "update-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<UpdateType> Range::property_update_policy() const
 {
   return Glib::PropertyProxy_ReadOnly<UpdateType>(this, "update-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Adjustment*> Range::property_adjustment() 
 {
   return Glib::PropertyProxy<Adjustment*>(this, "adjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Adjustment*> Range::property_adjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "adjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Range::property_inverted() 
 {
   return Glib::PropertyProxy<bool>(this, "inverted");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Range::property_inverted() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "inverted");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<SensitivityType> Range::property_lower_stepper_sensitivity() 
-{
-  return Glib::PropertyProxy<SensitivityType>(this, "lower-stepper-sensitivity");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<SensitivityType> Range::property_lower_stepper_sensitivity() const
-{
-  return Glib::PropertyProxy_ReadOnly<SensitivityType>(this, "lower-stepper-sensitivity");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<SensitivityType> Range::property_upper_stepper_sensitivity() 
-{
-  return Glib::PropertyProxy<SensitivityType>(this, "upper-stepper-sensitivity");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<SensitivityType> Range::property_upper_stepper_sensitivity() const
-{
-  return Glib::PropertyProxy_ReadOnly<SensitivityType>(this, "upper-stepper-sensitivity");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Range::on_value_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -627,6 +516,7 @@ void Gtk::Range::on_value_changed()
   if(base && base->value_changed)
     (*base->value_changed)(gobj());
 }
+
 void Gtk::Range::on_adjust_bounds(double new_value)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -636,6 +526,7 @@ void Gtk::Range::on_adjust_bounds(double new_value)
   if(base && base->adjust_bounds)
     (*base->adjust_bounds)(gobj(),new_value);
 }
+
 void Gtk::Range::on_move_slider(ScrollType scroll)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -645,9 +536,8 @@ void Gtk::Range::on_move_slider(ScrollType scroll)
   if(base && base->move_slider)
     (*base->move_slider)(gobj(),((GtkScrollType)(scroll)));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::Range::get_range_border_vfunc(GtkBorder* border) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -657,7 +547,6 @@ void Gtk::Range::get_range_border_vfunc(GtkBorder* border) const
   if(base && base->get_range_border)
     (*base->get_range_border)(const_cast<GtkRange*>(gobj()),border);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/range.h b/libs/gtkmm2/gtk/gtkmm/range.h
index ec67da392c..f84118bb65 100644
--- a/libs/gtkmm2/gtk/gtkmm/range.h
+++ b/libs/gtkmm2/gtk/gtkmm/range.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_RANGE_H
 #define _GTKMM_RANGE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -39,40 +38,6 @@ namespace Gtk
 namespace Gtk
 {
 
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- */
-enum SensitivityType
-{
-  SENSITIVITY_AUTO,
-  SENSITIVITY_ON,
-  SENSITIVITY_OFF
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::SensitivityType> : public Glib::Value_Enum<Gtk::SensitivityType>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
 class Adjustment;
 
 /** Base class for widgets which visualize an adjustment.
@@ -123,20 +88,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_value_changed();
   virtual void on_adjust_bounds(double new_value);
   virtual void on_move_slider(ScrollType scroll);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -204,16 +163,6 @@ public:
    * @return <tt>true</tt> if the range is inverted.
    */
   bool get_inverted() const;
-
-  
-  void set_lower_stepper_sensitivity(SensitivityType sensitivity);
-  
-  SensitivityType get_lower_stepper_sensitivity() const;
-  
-  void set_upper_stepper_sensitivity(SensitivityType sensitivity);
-  
-  SensitivityType get_upper_stepper_sensitivity() const;
-
   
   /** Sets the step and page sizes for the range.
    * The step size is used when the user clicks the Gtk::Scrollbar
@@ -246,73 +195,30 @@ public:
   double get_value() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %value_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_value_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %adjust_bounds(double new_value)</tt>
-   */
-
   Glib::SignalProxy1< void,double > signal_adjust_bounds();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %move_slider(ScrollType scroll)</tt>
-   */
-
   Glib::SignalProxy1< void,ScrollType > signal_move_slider();
 
   
   //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
   //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
-  /** The change_value signal is emitted when a scroll action is
-   * performed on a range.  It allows an application to determine the
-   * type of scroll event that occurred and the resultant new value.
-   * The application can handle the event itself and return true to
-   * prevent further processing.  Or, by returning false, it can pass
-   * the event to other handlers until the default GTK+ handler is
-   * reached.
-   *
-   * The value parameter is unrounded.  An application that overrides
-   * the change_value signal is responsible for clamping the value to
-   * the desired number of decimal digits; the default handler 
-   * clamps the value based on range->round_digits.
-   *
-   * It is not possible to use delayed update policies in an overridden
-   * change_value handler.
-   *
-   * @param scroll the type of scroll action that was performed.
-   * @param new_value the new value resulting from the scroll action.
-   * @result true to prevent other handlers from being invoked for the
-   * signal, or false to propagate the signal further.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>bool %change_value(ScrollType scroll, double new_value)</tt>
-   */
 
   Glib::SignalProxy2< bool,ScrollType,double > signal_change_value();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** How the range should be updated on the screen.
+  /** How the range should be updated on the screen.
    *
    * 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<UpdateType> property_update_policy() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** How the range should be updated on the screen.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -320,19 +226,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<UpdateType> property_update_policy() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkAdjustment that contains the current value of this range object.
+  /** The GtkAdjustment that contains the current value of this range object.
    *
    * 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<Adjustment*> property_adjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkAdjustment that contains the current value of this range object.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -340,19 +242,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Adjustment*> property_adjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Invert direction slider moves to increase range value.
+  /** Invert direction slider moves to increase range value.
    *
    * 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_inverted() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Invert direction slider moves to increase range value.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -360,53 +258,10 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_inverted() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The sensitivity policy for the stepper that points to the adjustment's lower side.
-   *
-   * 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<SensitivityType> property_lower_stepper_sensitivity() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The sensitivity policy for the stepper that points to the adjustment's lower side.
-   *
-   * 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<SensitivityType> property_lower_stepper_sensitivity() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The sensitivity policy for the stepper that points to the adjustment's upper side.
-   *
-   * 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<SensitivityType> property_upper_stepper_sensitivity() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The sensitivity policy for the stepper that points to the adjustment's upper side.
-   *
-   * 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<SensitivityType> property_upper_stepper_sensitivity() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
   
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_range_border_vfunc(GtkBorder* border) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual void get_range_border_vfunc(GtkBorder* border) const;
 
 
 };
@@ -422,8 +277,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Range* wrap(GtkRange* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_RANGE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/rc.cc b/libs/gtkmm2/gtk/gtkmm/rc.cc
index e4e4a8c999..7fcb207764 100644
--- a/libs/gtkmm2/gtk/gtkmm/rc.cc
+++ b/libs/gtkmm2/gtk/gtkmm/rc.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/rc.h>
 #include <gtkmm/private/rc_p.h>
 
@@ -237,19 +236,8 @@ void RcStyle_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* RcStyle_Class::wrap_new(GObject* object)
 {
@@ -308,11 +296,11 @@ Glib::RefPtr<RcStyle> RcStyle::copy() const
   return Glib::wrap(gtk_rc_style_copy(const_cast<GtkRcStyle*>(gobj())));
 }
 
- Glib::ustring RcStyle::get_name() const
+Glib::ustring RcStyle::get_name() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->name);
 }
- 
+
 void RcStyle::set_fg(StateType state, const Gdk::Color& color)
 {
   gobj()->fg[state] = *color.gobj();
@@ -353,22 +341,15 @@ Gdk::Color RcStyle::get_base(StateType state) const
   return Gdk::Color(const_cast<GdkColor*>(&gobj()->base[state]), true);
 }
 
- int RcStyle::get_xthickness() const
+int RcStyle::get_xthickness() const
 {
   return gobj()->xthickness;
 }
- 
- int RcStyle::get_ythickness() const
+
+int RcStyle::get_ythickness() const
 {
   return gobj()->ythickness;
 }
- 
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/rc.h b/libs/gtkmm2/gtk/gtkmm/rc.h
index 778a4ed7c8..003fd91c15 100644
--- a/libs/gtkmm2/gtk/gtkmm/rc.h
+++ b/libs/gtkmm2/gtk/gtkmm/rc.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_RC_H
 #define _GTKMM_RC_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -178,8 +177,8 @@ public:
   Glib::RefPtr<RcStyle> copy() const;
 
   void set_name(const Glib::ustring& name);
-   Glib::ustring get_name() const;
- 
+  Glib::ustring get_name() const;
+
   void set_bg_pixmap_name(Gtk::StateType state, const Glib::ustring& name);
   Glib::ustring get_bg_pixmap_name(Gtk::StateType state) const;
 
@@ -204,27 +203,21 @@ public:
 
 
   void set_xthickness(int xthickness);
-   int get_xthickness() const;
- 
+  int get_xthickness() const;
+
   void set_ythickness(int ythickness);
-   int get_ythickness() const;
- 
+  int get_ythickness() const;
+
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -296,7 +289,7 @@ public:
    *
    * @param settings a Gtk::Settings
    *
-   * @newin2p4
+   * Since: 2.4
    */
   static void reset_styles(const Glib::RefPtr<Settings>& settings);
 
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchooser.cc b/libs/gtkmm2/gtk/gtkmm/recentchooser.cc
deleted file mode 100644
index c056ad3f98..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchooser.cc
+++ /dev/null
@@ -1,956 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/recentchooser.h>
-#include <gtkmm/private/recentchooser_p.h>
-
-/* Copyright 2006 The gtkmm 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 <gtk/gtkrecentchooser.h>
-
-// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
-
-static int SignalProxy_Compare_gtk_callback(GtkRecentInfo* a, GtkRecentInfo* b, gpointer data)
-{
-  const Gtk::RecentChooser::SlotCompare* the_slot = static_cast<Gtk::RecentChooser::SlotCompare*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    return (*the_slot)(Glib::wrap(a, true /* take reference */), Glib::wrap(b, true /* take reference */));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-
-  return 0;
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_Compare_gtk_callback_destroy(gpointer data)
-{
-  delete static_cast<Gtk::RecentChooser::SlotCompare*>(data);
-}
-
-
-namespace Gtk
-{
-
-//Allow the generated code to work without the prefix:
-typedef RecentChooser::ListHandle_RecentInfos ListHandle_RecentInfos;
-
-void RecentChooser::set_sort_func(const SlotCompare& slot)
-{
-  SlotCompare* slot_copy = new SlotCompare(slot);
-
-  gtk_recent_chooser_set_sort_func(
-      gobj(),
-      &SignalProxy_Compare_gtk_callback, slot_copy,
-      &SignalProxy_Compare_gtk_callback_destroy);
-}
-
-Glib::StringArrayHandle RecentChooser::get_uris() const
-{
-  return Glib::StringArrayHandle(gtk_recent_chooser_get_uris(const_cast<GtkRecentChooser*>(gobj()), NULL));
-}
-
-void RecentChooser::unset_limit()
-{
-  gtk_recent_chooser_set_limit(gobj(), -1 /* See C docs */);
-}
-
-} // namespace Gtk
-
-
-namespace
-{
-
-
-static const Glib::SignalProxyInfo RecentChooser_signal_selection_changed_info =
-{
-  "selection-changed",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-static const Glib::SignalProxyInfo RecentChooser_signal_item_activated_info =
-{
-  "item-activated",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-} // anonymous namespace
-
-// static
-GType Glib::Value<Gtk::RecentSortType>::value_type()
-{
-  return gtk_recent_sort_type_get_type();
-}
-
-
-Gtk::RecentChooserError::RecentChooserError(Gtk::RecentChooserError::Code error_code, const Glib::ustring& error_message)
-:
-  Glib::Error (GTK_RECENT_CHOOSER_ERROR, error_code, error_message)
-{}
-
-Gtk::RecentChooserError::RecentChooserError(GError* gobject)
-:
-  Glib::Error (gobject)
-{}
-
-Gtk::RecentChooserError::Code Gtk::RecentChooserError::code() const
-{
-  return static_cast<Code>(Glib::Error::code());
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-void Gtk::RecentChooserError::throw_func(GError* gobject)
-{
-  throw Gtk::RecentChooserError(gobject);
-}
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Gtk::RecentChooserError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Gtk::RecentChooserError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-// static
-GType Glib::Value<Gtk::RecentChooserError::Code>::value_type()
-{
-  return gtk_recent_chooser_error_get_type();
-}
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::RecentChooser> wrap(GtkRecentChooser* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::RecentChooser>( dynamic_cast<Gtk::RecentChooser*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} // namespace Glib
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Interface_Class& RecentChooser_Class::init()
-{
-  if(!gtype_) // create the GType if necessary
-  {
-    // Glib::Interface_Class has to know the interface init function
-    // in order to add interfaces to implementing types.
-    class_init_func_ = &RecentChooser_Class::iface_init_function;
-
-    // We can not derive from another interface, and it is not necessary anyway.
-    gtype_ = gtk_recent_chooser_get_type();
-  }
-
-  return *this;
-}
-
-void RecentChooser_Class::iface_init_function(void* g_iface, void*)
-{
-  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
-
-  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
-  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
-  g_assert(klass != 0); 
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-  klass->get_current_uri = &get_current_uri_vfunc_callback;
-  klass->unselect_uri = &unselect_uri_vfunc_callback;
-  klass->select_all = &select_all_vfunc_callback;
-  klass->unselect_all = &unselect_all_vfunc_callback;
-  klass->get_recent_manager = &get_recent_manager_vfunc_callback;
-  klass->add_filter = &add_filter_vfunc_callback;
-  klass->remove_filter = &remove_filter_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-gchar* RecentChooser_Class::get_current_uri_vfunc_callback(GtkRecentChooser* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      return g_strdup((obj->get_current_uri_vfunc()).c_str());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->get_current_uri)
-      return (*base->get_current_uri)(self);
-  }
-
-  typedef gchar* RType;
-  return RType();
-}
-void RecentChooser_Class::unselect_uri_vfunc_callback(GtkRecentChooser* self, const gchar* uri)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->unselect_uri_vfunc(Glib::convert_const_gchar_ptr_to_ustring(uri)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->unselect_uri)
-      (*base->unselect_uri)(self, uri);
-  }
-}
-void RecentChooser_Class::select_all_vfunc_callback(GtkRecentChooser* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->select_all_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->select_all)
-      (*base->select_all)(self);
-  }
-}
-void RecentChooser_Class::unselect_all_vfunc_callback(GtkRecentChooser* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->unselect_all_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->unselect_all)
-      (*base->unselect_all)(self);
-  }
-}
-GtkRecentManager* RecentChooser_Class::get_recent_manager_vfunc_callback(GtkRecentChooser* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      return Glib::unwrap(obj->get_recent_manager_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->get_recent_manager)
-      return (*base->get_recent_manager)(self);
-  }
-
-  typedef GtkRecentManager* RType;
-  return RType();
-}
-void RecentChooser_Class::add_filter_vfunc_callback(GtkRecentChooser* self, GtkRecentFilter* filter)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->add_filter_vfunc(*Glib::wrap(filter)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->add_filter)
-      (*base->add_filter)(self, filter);
-  }
-}
-void RecentChooser_Class::remove_filter_vfunc_callback(GtkRecentChooser* self, GtkRecentFilter* filter)
-{
-  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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->remove_filter_vfunc(*Glib::wrap(filter)
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  else
-  {
-    BaseClassType *const base = static_cast<BaseClassType*>(
-        g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Get the interface.
-)    );
-
-    // Call the original underlying C function:
-    if(base && base->remove_filter)
-      (*base->remove_filter)(self, filter);
-  }
-}
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* RecentChooser_Class::wrap_new(GObject* object)
-{
-  return new RecentChooser((GtkRecentChooser*)(object));
-}
-
-
-/* The implementation: */
-
-RecentChooser::RecentChooser()
-:
-  Glib::Interface(recentchooser_class_.init())
-{}
-
-RecentChooser::RecentChooser(GtkRecentChooser* castitem)
-:
-  Glib::Interface((GObject*)(castitem))
-{}
-
-RecentChooser::~RecentChooser()
-{}
-
-// static
-void RecentChooser::add_interface(GType gtype_implementer)
-{
-  recentchooser_class_.init().add_interface(gtype_implementer);
-}
-
-RecentChooser::CppClassType RecentChooser::recentchooser_class_; // initialize static member
-
-GType RecentChooser::get_type()
-{
-  return recentchooser_class_.init().get_type();
-}
-
-GType RecentChooser::get_base_type()
-{
-  return gtk_recent_chooser_get_type();
-}
-
-
-void RecentChooser::set_show_private(bool show_private)
-{
-gtk_recent_chooser_set_show_private(gobj(), static_cast<int>(show_private)); 
-}
-
-bool RecentChooser::get_show_private() const
-{
-  return gtk_recent_chooser_get_show_private(const_cast<GtkRecentChooser*>(gobj()));
-}
-
-void RecentChooser::set_show_not_found(bool show_not_found)
-{
-gtk_recent_chooser_set_show_not_found(gobj(), static_cast<int>(show_not_found)); 
-}
-
-bool RecentChooser::get_show_not_found() const
-{
-  return gtk_recent_chooser_get_show_not_found(const_cast<GtkRecentChooser*>(gobj()));
-}
-
-void RecentChooser::set_select_multiple(bool select_multiple)
-{
-gtk_recent_chooser_set_select_multiple(gobj(), static_cast<int>(select_multiple)); 
-}
-
-bool RecentChooser::get_select_multiple() const
-{
-  return gtk_recent_chooser_get_select_multiple(const_cast<GtkRecentChooser*>(gobj()));
-}
-
-void RecentChooser::set_limit(int limit)
-{
-gtk_recent_chooser_set_limit(gobj(), limit); 
-}
-
-int RecentChooser::get_limit() const
-{
-  return gtk_recent_chooser_get_limit(const_cast<GtkRecentChooser*>(gobj()));
-}
-
-void RecentChooser::set_local_only(bool local_only)
-{
-gtk_recent_chooser_set_local_only(gobj(), static_cast<int>(local_only)); 
-}
-
-bool RecentChooser::get_local_only() const
-{
-  return gtk_recent_chooser_get_local_only(const_cast<GtkRecentChooser*>(gobj()));
-}
-
-void RecentChooser::set_show_tips(bool show_tips)
-{
-gtk_recent_chooser_set_show_tips(gobj(), static_cast<int>(show_tips)); 
-}
-
-bool RecentChooser::get_show_tips() const
-{
-  return gtk_recent_chooser_get_show_tips(const_cast<GtkRecentChooser*>(gobj()));
-}
-
-void RecentChooser::set_show_icons(bool show_icons)
-{
-gtk_recent_chooser_set_show_icons(gobj(), static_cast<int>(show_icons)); 
-}
-
-bool RecentChooser::get_show_icons() const
-{
-  return gtk_recent_chooser_get_show_icons(const_cast<GtkRecentChooser*>(gobj()));
-}
-
-void RecentChooser::set_sort_type(RecentSortType sort_type)
-{
-gtk_recent_chooser_set_sort_type(gobj(), ((GtkRecentSortType)(sort_type))); 
-}
-
-RecentSortType RecentChooser::get_sort_type() const
-{
-  return ((RecentSortType)(gtk_recent_chooser_get_sort_type(const_cast<GtkRecentChooser*>(gobj()))));
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-bool RecentChooser::set_current_uri(const Glib::ustring& uri)
-#else
-bool RecentChooser::set_current_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_recent_chooser_set_current_uri(gobj(), uri.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-Glib::ustring RecentChooser::get_current_uri() const
-{
-  return Glib::convert_return_gchar_ptr_to_ustring(gtk_recent_chooser_get_current_uri(const_cast<GtkRecentChooser*>(gobj())));
-}
-
-Glib::RefPtr<RecentInfo> RecentChooser::get_current_item()
-{
-
-  Glib::RefPtr<RecentInfo> retvalue = Glib::wrap(gtk_recent_chooser_get_current_item(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const RecentInfo> RecentChooser::get_current_item() const
-{
-
-  Glib::RefPtr<const RecentInfo> retvalue = Glib::wrap(gtk_recent_chooser_get_current_item(const_cast<GtkRecentChooser*>(gobj())));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-bool RecentChooser::select_uri(const Glib::ustring& uri)
-#else
-bool RecentChooser::select_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_recent_chooser_select_uri(gobj(), uri.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-void RecentChooser::unselect_uri(const Glib::ustring& uri)
-{
-gtk_recent_chooser_unselect_uri(gobj(), uri.c_str()); 
-}
-
-void RecentChooser::select_all()
-{
-gtk_recent_chooser_select_all(gobj()); 
-}
-
-void RecentChooser::unselect_all()
-{
-gtk_recent_chooser_unselect_all(gobj()); 
-}
-
-ListHandle_RecentInfos RecentChooser::get_items() const
-{
-  return ListHandle_RecentInfos(gtk_recent_chooser_get_items(const_cast<GtkRecentChooser*>(gobj())), Glib::OWNERSHIP_SHALLOW);
-}
-
-void RecentChooser::add_filter(const RecentFilter& filter)
-{
-gtk_recent_chooser_add_filter(gobj(), const_cast<GtkRecentFilter*>((filter).gobj())); 
-}
-
-void RecentChooser::remove_filter(const RecentFilter& filter)
-{
-gtk_recent_chooser_remove_filter(gobj(), const_cast<GtkRecentFilter*>((filter).gobj())); 
-}
-
-Glib::SListHandle<RecentFilter*> RecentChooser::list_filters()
-{
-  return Glib::SListHandle<RecentFilter*>(gtk_recent_chooser_list_filters(gobj()), Glib::OWNERSHIP_SHALLOW);
-}
-
-Glib::SListHandle<const RecentFilter*> RecentChooser::list_filters() const
-{
-  return Glib::SListHandle<const RecentFilter*>(gtk_recent_chooser_list_filters(const_cast<GtkRecentChooser*>(gobj())), Glib::OWNERSHIP_SHALLOW);
-}
-
-void RecentChooser::set_filter(const RecentFilter& filter)
-{
-gtk_recent_chooser_set_filter(gobj(), const_cast<GtkRecentFilter*>((filter).gobj())); 
-}
-
-RecentFilter* RecentChooser::get_filter()
-{
-  return Glib::wrap(gtk_recent_chooser_get_filter(gobj()));
-}
-
-const RecentFilter* RecentChooser::get_filter() const
-{
-  return Glib::wrap(gtk_recent_chooser_get_filter(const_cast<GtkRecentChooser*>(gobj())));
-}
-
-
-Glib::SignalProxy0< void > RecentChooser::signal_selection_changed()
-{
-  return Glib::SignalProxy0< void >(this, &RecentChooser_signal_selection_changed_info);
-}
-
-
-Glib::SignalProxy0< void > RecentChooser::signal_item_activated()
-{
-  return Glib::SignalProxy0< void >(this, &RecentChooser_signal_item_activated_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<RecentManager> > RecentChooser::property_recent_manager() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<RecentManager> >(this, "recent-manager");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> RecentChooser::property_show_private() 
-{
-  return Glib::PropertyProxy<bool>(this, "show-private");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_private() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-private");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> RecentChooser::property_show_tips() 
-{
-  return Glib::PropertyProxy<bool>(this, "show-tips");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_tips() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-tips");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> RecentChooser::property_show_icons() 
-{
-  return Glib::PropertyProxy<bool>(this, "show-icons");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_icons() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-icons");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> RecentChooser::property_show_not_found() 
-{
-  return Glib::PropertyProxy<bool>(this, "show-not-found");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_show_not_found() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-not-found");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> RecentChooser::property_select_multiple() 
-{
-  return Glib::PropertyProxy<bool>(this, "select-multiple");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_select_multiple() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "select-multiple");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> RecentChooser::property_local_only() 
-{
-  return Glib::PropertyProxy<bool>(this, "local-only");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> RecentChooser::property_local_only() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "local-only");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> RecentChooser::property_limit() 
-{
-  return Glib::PropertyProxy<int>(this, "limit");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> RecentChooser::property_limit() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "limit");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<RecentSortType> RecentChooser::property_sort_type() 
-{
-  return Glib::PropertyProxy<RecentSortType>(this, "sort-type");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<RecentSortType> RecentChooser::property_sort_type() const
-{
-  return Glib::PropertyProxy_ReadOnly<RecentSortType>(this, "sort-type");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<RecentFilter*> RecentChooser::property_filter() 
-{
-  return Glib::PropertyProxy<RecentFilter*>(this, "filter");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<RecentFilter*> RecentChooser::property_filter() const
-{
-  return Glib::PropertyProxy_ReadOnly<RecentFilter*>(this, "filter");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-Glib::ustring Gtk::RecentChooser::get_current_uri_vfunc() const
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->get_current_uri)
-    return Glib::convert_const_gchar_ptr_to_ustring((*base->get_current_uri)(const_cast<GtkRecentChooser*>(gobj())));
-
-  typedef Glib::ustring RType;
-  return RType();
-}
-void Gtk::RecentChooser::unselect_uri_vfunc(const Glib::ustring& uri) 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->unselect_uri)
-    (*base->unselect_uri)(gobj(),uri.c_str());
-}
-void Gtk::RecentChooser::select_all_vfunc() 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->select_all)
-    (*base->select_all)(gobj());
-}
-void Gtk::RecentChooser::unselect_all_vfunc() 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->unselect_all)
-    (*base->unselect_all)(gobj());
-}
-Glib::RefPtr<RecentManager> Gtk::RecentChooser::get_recent_manager_vfunc() 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->get_recent_manager)
-    return Glib::wrap((*base->get_recent_manager)(gobj()));
-
-  typedef Glib::RefPtr<RecentManager> RType;
-  return RType();
-}
-void Gtk::RecentChooser::add_filter_vfunc(const RecentFilter& filter) 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->add_filter)
-    (*base->add_filter)(gobj(),const_cast<GtkRecentFilter*>((filter).gobj()));
-}
-void Gtk::RecentChooser::remove_filter_vfunc(const RecentFilter& filter) 
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_interface_peek_parent( // Get the parent interface of the interface (The original underlying C interface).
-g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) // Get the interface.
-)  );
-
-  if(base && base->remove_filter)
-    (*base->remove_filter)(gobj(),const_cast<GtkRecentFilter*>((filter).gobj()));
-}
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchooser.h b/libs/gtkmm2/gtk/gtkmm/recentchooser.h
deleted file mode 100644
index 327c819b51..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchooser.h
+++ /dev/null
@@ -1,597 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSER_H
-#define _GTKMM_RECENTCHOOSER_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkrecentchooser.h>
-#include <glibmm/interface.h>
-#include <gtkmm/recentinfo.h>
-#include <gtkmm/recentfilter.h>
-#include <gtkmm/recentmanager.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkRecentChooser GtkRecentChooser;
-typedef struct _GtkRecentChooserClass GtkRecentChooserClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class RecentChooser_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- */
-enum RecentSortType
-{
-  RECENT_SORT_NONE,
-  RECENT_SORT_MRU,
-  RECENT_SORT_LRU,
-  RECENT_SORT_CUSTOM
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::RecentSortType> : public Glib::Value_Enum<Gtk::RecentSortType>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** Exception class for Gtk::RecentChooser errors.
- */
-class RecentChooserError : public Glib::Error
-{
-public:
-  enum Code
-  {
-    NOT_FOUND,
-    INVALID_URI
-  };
-
-  RecentChooserError(Code error_code, const Glib::ustring& error_message);
-  explicit RecentChooserError(GError* gobject);
-  Code code() const;
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  friend void wrap_init(); // uses throw_func()
-#endif
-};
-
-} // namespace Gtk
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::RecentChooserError::Code> : public Glib::Value_Enum<Gtk::RecentChooserError::Code>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** RecentChooser is an interface that can be implemented by widgets
- * displaying the list of recently used files.  In GTK+, the main objects
- * that implement this interface are RecentChooserWidget, RecentChooserDialog
- * and RecentChooserMenu.
- *
- * @newin2p10
- *
- * @ingroup RecentFiles
- */
-
-class RecentChooser : public Glib::Interface
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef RecentChooser CppObjectType;
-  typedef RecentChooser_Class CppClassType;
-  typedef GtkRecentChooser BaseObjectType;
-  typedef GtkRecentChooserIface BaseClassType;
-
-private:
-  friend class RecentChooser_Class;
-  static CppClassType recentchooser_class_;
-
-  // noncopyable
-  RecentChooser(const RecentChooser&);
-  RecentChooser& operator=(const RecentChooser&);
-
-protected:
-  RecentChooser(); // you must derive from this class
-  explicit RecentChooser(GtkRecentChooser* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~RecentChooser();
-
-  static void add_interface(GType gtype_implementer);
-
-#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 GObject.
-  GtkRecentChooser*       gobj()       { return reinterpret_cast<GtkRecentChooser*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.  
-  const GtkRecentChooser* gobj() const { return reinterpret_cast<GtkRecentChooser*>(gobject_); }
-
-private:
-
-public:
-
-  
-  void set_show_private(bool show_private = true);
-  
-  bool get_show_private() const;
-  
-  void set_show_not_found(bool show_not_found = true);
-  
-  bool get_show_not_found() const;
-  
-  void set_select_multiple(bool select_multiple = true);
-  
-  bool get_select_multiple() const;
-  
-  void set_limit(int limit);
-  void unset_limit();
-  
-  int get_limit() const;
-  
-  void set_local_only(bool local_only = true);
-  
-  bool get_local_only() const;
-  
-  void set_show_tips(bool show_tips = true);
-  
-  bool get_show_tips() const;
-
-  // TODO: These methods are declared in gtkrecentchooser.h but throw errors when
-  // using them on RecentChooserWidget or RecentChooserDialog.
-  // RecentChooserMenu reimplements them.
-  // In an email titled "GtkRecentChooser API glitch", Emmanuele Bassi said that these would be 
-  // deprecated in GTK+ 2.12. murrayc.
-  //_WRAP_METHOD(void set_show_numbers(bool show_numbers = true), gtk_recent_chooser_set_show_numbers)
-  //_WRAP_METHOD(bool get_show_numbers() const, gtk_recent_chooser_get_show_numbers)
-  
-
-  void set_show_icons(bool show_icons = true);
-  
-  bool get_show_icons() const;
-  
-  void set_sort_type(RecentSortType sort_type);
-  
-  RecentSortType get_sort_type() const;
-
-
-  /** This callback should return -1 if b compares before a, 0 if they compare
-   * equal and 1 if a compares after b.
-   * For instance, int on_sort_compare(const Glib::RefPtr<Gtk::RecentInfo>& a, const Gtk::RecentInfo& b);
-   */
-  typedef sigc::slot<int, const Glib::RefPtr<RecentInfo>&, const Glib::RefPtr<RecentInfo>&> SlotCompare;
-  
-
-  /** Sets the comparison function used when sorting the list of recently
-   * used resources and the sort type is #RECENT_SORT_CUSTOM.
-   */
-  void set_sort_func(const SlotCompare& slot);
-
-  // TODO: Return type should be void since it will never return false but
-  // throwing RecentChooserError instead
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  bool set_current_uri(const Glib::ustring& uri);
-#else
-  bool set_current_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-  Glib::ustring get_current_uri() const;
-  
-  Glib::RefPtr<RecentInfo> get_current_item();
-  
-  Glib::RefPtr<const RecentInfo> get_current_item() const;
-  // TODO: Same here
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  bool select_uri(const Glib::ustring& uri);
-#else
-  bool select_uri(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-  void unselect_uri(const Glib::ustring& uri);
-  
-  void select_all();
-  
-  void unselect_all();
-
-  typedef Glib::ListHandle<RecentInfo, RecentInfoTraits> ListHandle_RecentInfos;
-  
-
-  ListHandle_RecentInfos get_items() const;
-
-  /** Gets the URI of the recently used resources.
-   *
-   * The return value of this function is affected by the "sort-type" and
-   * "limit" properties of the recent chooser.
-   */
-  Glib::StringArrayHandle get_uris() const;
-  
-
-  void add_filter(const RecentFilter& filter);
-  
-  void remove_filter(const RecentFilter& filter);
-  
-  Glib::SListHandle<RecentFilter*> list_filters();
-  
-  Glib::SListHandle<const RecentFilter*> list_filters() const;
-  
-  void set_filter(const RecentFilter& filter);
-  
-  RecentFilter* get_filter();
-  
-  const RecentFilter* get_filter() const;
-
-  /** This signal is emitted when there is a change in the set of
-   * selected recently used resources.  This can happen when a user
-   * modifies the selection with the mouse or the keyboard, or when
-   * explicitely calling functions to change the selection.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %selection_changed()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_selection_changed();
-
-
-  /** This signal is emitted when the user "activates" a recent item
-   * in the recent chooser.  This can happen by double-clicking on an item
-   * in the recently used resources list, or by pressing
-   * <keycap>Enter</keycap>.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %item_activated()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_item_activated();
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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<RecentManager> > property_recent_manager() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_private() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_private() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_tips() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_tips() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_icons() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_icons() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_not_found() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_show_not_found() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_select_multiple() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_select_multiple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_local_only() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_local_only() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_limit() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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_limit() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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<RecentSortType> property_sort_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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<RecentSortType> property_sort_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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<RecentFilter*> property_filter() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
-   *
-   * 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<RecentFilter*> property_filter() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-protected:
-
-  // As in editable.hg
-  
-
-  // TODO: How to wrap those vfuncs?
-
-  //__CONVERSION(`ListHandle_RecentInfos', `GList*', `($3).data()')
-  //__CONVERSION(`Glib::SListHandle<RecentFilter*>', `GSList*', `($3).data()')
-
-  //_WRAP_VFUNC(bool set_current_uri(const Glib::ustring& uri), "set_current_uri", errthrow)
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::ustring get_current_uri_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //_WRAP_VFUNC(bool select_uri(const Glib::ustring& uri), "select_uri", errthrow)
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void unselect_uri_vfunc(const Glib::ustring& uri);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void select_all_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void unselect_all_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //_WRAP_VFUNC(ArrayHandle_RecentInfos get_items() const, "get_items")
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<RecentManager> get_recent_manager_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void add_filter_vfunc(const RecentFilter& filter);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void remove_filter_vfunc(const RecentFilter& filter);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //_WRAP_VFUNC(Glib::SListHandle<RecentFilter*> list_filters(), "list_filters")
-  //_WRAP_VFUNC(void set_sort_func(const SlotCompare& slot), "set_sort_func")
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
- 
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::RecentChooser
-   * @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<Gtk::RecentChooser> wrap(GtkRecentChooser* object, bool take_copy = false);
-
-} // namespace Glib
-
-
-#endif /* _GTKMM_RECENTCHOOSER_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchooserdialog.cc b/libs/gtkmm2/gtk/gtkmm/recentchooserdialog.cc
deleted file mode 100644
index 77b2390280..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchooserdialog.cc
+++ /dev/null
@@ -1,172 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/recentchooserdialog.h>
-#include <gtkmm/private/recentchooserdialog_p.h>
-
-/* Copyright 2006 The gtkmm 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 <gtk/gtkrecentchooserdialog.h>
-
-
-namespace Gtk
-{
-
-RecentChooserDialog::RecentChooserDialog(Gtk::Window& parent, const Glib::ustring& title)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(recentchooserdialog_class_.init(), "title",title.c_str(), (char*) 0))
-{
-  set_transient_for(parent);
-}
-
-RecentChooserDialog::RecentChooserDialog(const Glib::ustring& title)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(recentchooserdialog_class_.init(), "title",title.c_str(), (char*) 0))
-{
-}
-
-RecentChooserDialog::RecentChooserDialog(const Glib::ustring& title, const Glib::RefPtr<RecentManager>& recent_manager)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(recentchooserdialog_class_.init(), "title",title.c_str(),"recent-manager",recent_manager->gobj(), (char*) 0))
-{
-}
-
-RecentChooserDialog::RecentChooserDialog(Gtk::Window& parent, const Glib::ustring& title, const Glib::RefPtr<RecentManager>& recent_manager)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Dialog(Glib::ConstructParams(recentchooserdialog_class_.init(), "title",title.c_str(),"recent-manager",recent_manager->gobj(), (char*) 0))
-{
-  set_transient_for(parent);
-}
-
-} // namespace Gtk
-
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::RecentChooserDialog* wrap(GtkRecentChooserDialog* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::RecentChooserDialog *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& RecentChooserDialog_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_ = &RecentChooserDialog_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(gtk_recent_chooser_dialog_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  RecentChooser::add_interface(get_type());
-  }
-
-  return *this;
-}
-
-void RecentChooserDialog_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* RecentChooserDialog_Class::wrap_new(GObject* o)
-{
-  return new RecentChooserDialog((GtkRecentChooserDialog*)(o)); //top-level windows can not be manage()ed.
-
-}
-
-
-/* The implementation: */
-
-RecentChooserDialog::RecentChooserDialog(const Glib::ConstructParams& construct_params)
-:
-  Gtk::Dialog(construct_params)
-{
-  }
-
-RecentChooserDialog::RecentChooserDialog(GtkRecentChooserDialog* castitem)
-:
-  Gtk::Dialog((GtkDialog*)(castitem))
-{
-  }
-
-RecentChooserDialog::~RecentChooserDialog()
-{
-  destroy_();
-}
-
-RecentChooserDialog::CppClassType RecentChooserDialog::recentchooserdialog_class_; // initialize static member
-
-GType RecentChooserDialog::get_type()
-{
-  return recentchooserdialog_class_.init().get_type();
-}
-
-GType RecentChooserDialog::get_base_type()
-{
-  return gtk_recent_chooser_dialog_get_type();
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchooserdialog.h b/libs/gtkmm2/gtk/gtkmm/recentchooserdialog.h
deleted file mode 100644
index cb80a90f24..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchooserdialog.h
+++ /dev/null
@@ -1,145 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSERDIALOG_H
-#define _GTKMM_RECENTCHOOSERDIALOG_H
-
-
-#include <glibmm.h>
-
-/* recentchooserdialog.h
- *
- * Copyright (C) 2006 The gtkmm 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/dialog.h>
-#include <gtkmm/recentchooser.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkRecentChooserDialog GtkRecentChooserDialog;
-typedef struct _GtkRecentChooserDialogClass GtkRecentChooserDialogClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class RecentChooserDialog_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** RecentChooserDialog is a dialog box suitable for displaying the recently
- * used documents. This widget works by putting a RecentChooserWidget inside
- * a Dialog. It exposes the RecentChooser interface, so you can use
- * all the RecentChooser functions on the recent chooser dialog as well as
- * those for Dialog.
- *
- * Note that RecentChooserDialog does not have any methods of its own.
- * Instead, you should use the functions that work on a RecentChooser.
- *
- * @newin2p10
- *
- * @ingroup RecentFiles
- */
-
-class RecentChooserDialog
-  : public Dialog,
-    public RecentChooser
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentChooserDialog CppObjectType;
-  typedef RecentChooserDialog_Class CppClassType;
-  typedef GtkRecentChooserDialog BaseObjectType;
-  typedef GtkRecentChooserDialogClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~RecentChooserDialog();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class RecentChooserDialog_Class;
-  static CppClassType recentchooserdialog_class_;
-
-  // noncopyable
-  RecentChooserDialog(const RecentChooserDialog&);
-  RecentChooserDialog& operator=(const RecentChooserDialog&);
-
-protected:
-  explicit RecentChooserDialog(const Glib::ConstructParams& construct_params);
-  explicit RecentChooserDialog(GtkRecentChooserDialog* 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.
-  GtkRecentChooserDialog*       gobj()       { return reinterpret_cast<GtkRecentChooserDialog*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkRecentChooserDialog* gobj() const { return reinterpret_cast<GtkRecentChooserDialog*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-  
-public:
-  
-  explicit RecentChooserDialog(Gtk::Window& parent, const Glib::ustring& title);
-  explicit RecentChooserDialog(const Glib::ustring& title);
-
-  
-  explicit RecentChooserDialog(Gtk::Window& parent, const Glib::ustring& title, const Glib::RefPtr<RecentManager>& recent_manager);
-  explicit RecentChooserDialog(const Glib::ustring& title, const Glib::RefPtr<RecentManager>& recent_manager);
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::RecentChooserDialog
-   * @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.
-   */
-  Gtk::RecentChooserDialog* wrap(GtkRecentChooserDialog* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_RECENTCHOOSERDIALOG_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchoosermenu.cc b/libs/gtkmm2/gtk/gtkmm/recentchoosermenu.cc
deleted file mode 100644
index 5664cdc9b8..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchoosermenu.cc
+++ /dev/null
@@ -1,165 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/recentchoosermenu.h>
-#include <gtkmm/private/recentchoosermenu_p.h>
-
-/* Copyright 2006 The gtkmm 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 <gtk/gtkrecentchoosermenu.h>
-
-namespace Gtk
-{
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::RecentChooserMenu* wrap(GtkRecentChooserMenu* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::RecentChooserMenu *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& RecentChooserMenu_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_ = &RecentChooserMenu_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(gtk_recent_chooser_menu_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  RecentChooser::add_interface(get_type());
-  }
-
-  return *this;
-}
-
-void RecentChooserMenu_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* RecentChooserMenu_Class::wrap_new(GObject* o)
-{
-  return manage(new RecentChooserMenu((GtkRecentChooserMenu*)(o)));
-
-}
-
-
-/* The implementation: */
-
-RecentChooserMenu::RecentChooserMenu(const Glib::ConstructParams& construct_params)
-:
-  Gtk::Menu(construct_params)
-{
-  }
-
-RecentChooserMenu::RecentChooserMenu(GtkRecentChooserMenu* castitem)
-:
-  Gtk::Menu((GtkMenu*)(castitem))
-{
-  }
-
-RecentChooserMenu::~RecentChooserMenu()
-{
-  destroy_();
-}
-
-RecentChooserMenu::CppClassType RecentChooserMenu::recentchoosermenu_class_; // initialize static member
-
-GType RecentChooserMenu::get_type()
-{
-  return recentchoosermenu_class_.init().get_type();
-}
-
-GType RecentChooserMenu::get_base_type()
-{
-  return gtk_recent_chooser_menu_get_type();
-}
-
-
-RecentChooserMenu::RecentChooserMenu()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Menu(Glib::ConstructParams(recentchoosermenu_class_.init()))
-{
-  }
-
-RecentChooserMenu::RecentChooserMenu(const Glib::RefPtr<RecentManager>& recent_manager)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Menu(Glib::ConstructParams(recentchoosermenu_class_.init(), "recent_manager", Glib::unwrap(recent_manager), (char*) 0))
-{
-  }
-
-void RecentChooserMenu::set_show_numbers(bool show_numbers)
-{
-gtk_recent_chooser_menu_set_show_numbers(gobj(), static_cast<int>(show_numbers)); 
-}
-
-bool RecentChooserMenu::get_show_numbers() const
-{
-  return gtk_recent_chooser_menu_get_show_numbers(const_cast<GtkRecentChooserMenu*>(gobj()));
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchoosermenu.h b/libs/gtkmm2/gtk/gtkmm/recentchoosermenu.h
deleted file mode 100644
index 7d455cb3ee..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchoosermenu.h
+++ /dev/null
@@ -1,144 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSERMENU_H
-#define _GTKMM_RECENTCHOOSERMENU_H
-
-
-#include <glibmm.h>
-
-/* recentchoosermenu.h
- *
- * Copyright (C) 2006 The gtkmm 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/menu.h>
-#include <gtkmm/recentchooser.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkRecentChooserMenu GtkRecentChooserMenu;
-typedef struct _GtkRecentChooserMenuClass GtkRecentChooserMenuClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class RecentChooserMenu_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** RecentChooserMenu is a widget suitable for displaying recently used files
- * inside a menu.  It can be used to set a sub-menu of a MenuItem using
- * MenuItem::item_set_submenu(), or as the menu of a MenuToolButton.
- *
- * Note that RecentChooserMenu does not have any methods of its own. Instead,
- * you should use the functions that work on a RecentChooser.
- *
- * @newin2p10
- *
- * @ingroup RecentFiles
- */
-
-class RecentChooserMenu
-  : public Menu,
-    public RecentChooser
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentChooserMenu CppObjectType;
-  typedef RecentChooserMenu_Class CppClassType;
-  typedef GtkRecentChooserMenu BaseObjectType;
-  typedef GtkRecentChooserMenuClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~RecentChooserMenu();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class RecentChooserMenu_Class;
-  static CppClassType recentchoosermenu_class_;
-
-  // noncopyable
-  RecentChooserMenu(const RecentChooserMenu&);
-  RecentChooserMenu& operator=(const RecentChooserMenu&);
-
-protected:
-  explicit RecentChooserMenu(const Glib::ConstructParams& construct_params);
-  explicit RecentChooserMenu(GtkRecentChooserMenu* 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.
-  GtkRecentChooserMenu*       gobj()       { return reinterpret_cast<GtkRecentChooserMenu*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkRecentChooserMenu* gobj() const { return reinterpret_cast<GtkRecentChooserMenu*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-  
-public:
-  RecentChooserMenu();
-
-  explicit RecentChooserMenu(const Glib::RefPtr<RecentManager>& recent_manager);
-
-  
-  void set_show_numbers(bool show_numbers = true);
-  
-  bool get_show_numbers() const;
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::RecentChooserMenu
-   * @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.
-   */
-  Gtk::RecentChooserMenu* wrap(GtkRecentChooserMenu* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_RECENTCHOOSERMENU_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchooserwidget.cc b/libs/gtkmm2/gtk/gtkmm/recentchooserwidget.cc
deleted file mode 100644
index 1f8cf7e837..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchooserwidget.cc
+++ /dev/null
@@ -1,155 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/recentchooserwidget.h>
-#include <gtkmm/private/recentchooserwidget_p.h>
-
-/* Copyright 2006 The gtkmm 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 <gtk/gtkrecentchooserwidget.h>
-
-namespace Gtk
-{
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Gtk::RecentChooserWidget* wrap(GtkRecentChooserWidget* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::RecentChooserWidget *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& RecentChooserWidget_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_ = &RecentChooserWidget_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(gtk_recent_chooser_widget_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  RecentChooser::add_interface(get_type());
-  }
-
-  return *this;
-}
-
-void RecentChooserWidget_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* RecentChooserWidget_Class::wrap_new(GObject* o)
-{
-  return manage(new RecentChooserWidget((GtkRecentChooserWidget*)(o)));
-
-}
-
-
-/* The implementation: */
-
-RecentChooserWidget::RecentChooserWidget(const Glib::ConstructParams& construct_params)
-:
-  Gtk::VBox(construct_params)
-{
-  }
-
-RecentChooserWidget::RecentChooserWidget(GtkRecentChooserWidget* castitem)
-:
-  Gtk::VBox((GtkVBox*)(castitem))
-{
-  }
-
-RecentChooserWidget::~RecentChooserWidget()
-{
-  destroy_();
-}
-
-RecentChooserWidget::CppClassType RecentChooserWidget::recentchooserwidget_class_; // initialize static member
-
-GType RecentChooserWidget::get_type()
-{
-  return recentchooserwidget_class_.init().get_type();
-}
-
-GType RecentChooserWidget::get_base_type()
-{
-  return gtk_recent_chooser_widget_get_type();
-}
-
-
-RecentChooserWidget::RecentChooserWidget()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::VBox(Glib::ConstructParams(recentchooserwidget_class_.init()))
-{
-  }
-
-RecentChooserWidget::RecentChooserWidget(const Glib::RefPtr<RecentManager>& recent_manager)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::VBox(Glib::ConstructParams(recentchooserwidget_class_.init(), "recent_manager", Glib::unwrap(recent_manager), (char*) 0))
-{
-  }
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentchooserwidget.h b/libs/gtkmm2/gtk/gtkmm/recentchooserwidget.h
deleted file mode 100644
index 3e3f77a0ba..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentchooserwidget.h
+++ /dev/null
@@ -1,138 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTCHOOSERWIDGET_H
-#define _GTKMM_RECENTCHOOSERWIDGET_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/box.h>
-#include <gtkmm/recentchooser.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkRecentChooserWidget GtkRecentChooserWidget;
-typedef struct _GtkRecentChooserWidgetClass GtkRecentChooserWidgetClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class RecentChooserWidget_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** RecentChooserWidget is a widget suitable for selecting recently used
- * files.  It is the main building block of a RecentChooserDialog. Most
- * applications will only need to use the latter; you can use
- * RecentChooserWidget as part of a larger window if you have special needs.
- *
- * Note that RecentChooserWidget does not have any methods of its own.
- * Instead, you should use the functions that work on a RecentChooser.
- *
- * @newin2p10
- *
- * @ingroup RecentFiles
- */
-
-class RecentChooserWidget
-: public VBox,
-  public RecentChooser
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentChooserWidget CppObjectType;
-  typedef RecentChooserWidget_Class CppClassType;
-  typedef GtkRecentChooserWidget BaseObjectType;
-  typedef GtkRecentChooserWidgetClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~RecentChooserWidget();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class RecentChooserWidget_Class;
-  static CppClassType recentchooserwidget_class_;
-
-  // noncopyable
-  RecentChooserWidget(const RecentChooserWidget&);
-  RecentChooserWidget& operator=(const RecentChooserWidget&);
-
-protected:
-  explicit RecentChooserWidget(const Glib::ConstructParams& construct_params);
-  explicit RecentChooserWidget(GtkRecentChooserWidget* 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.
-  GtkRecentChooserWidget*       gobj()       { return reinterpret_cast<GtkRecentChooserWidget*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkRecentChooserWidget* gobj() const { return reinterpret_cast<GtkRecentChooserWidget*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-  
-public:
-  RecentChooserWidget();
-  
-  explicit RecentChooserWidget(const Glib::RefPtr<RecentManager>& recent_manager);
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::RecentChooserWidget
-   * @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.
-   */
-  Gtk::RecentChooserWidget* wrap(GtkRecentChooserWidget* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_RECENTCHOOSERWIDGET_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentfilter.cc b/libs/gtkmm2/gtk/gtkmm/recentfilter.cc
deleted file mode 100644
index 661fe3a257..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentfilter.cc
+++ /dev/null
@@ -1,265 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/recentfilter.h>
-#include <gtkmm/private/recentfilter_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkrecentfilter.h>
-#include <gtk/gtktypebuiltins.h>
-
-#include <glibmm/ustring.h>
-
-// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
-
-static gboolean SignalProxy_Custom_gtk_callback(const GtkRecentFilterInfo* filter_info, gpointer data)
-{
-  const Gtk::RecentFilter::SlotCustom* the_slot = static_cast<Gtk::RecentFilter::SlotCustom*>(data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    // Create a suitable C++ instance to pass to the C++ method:
-    Gtk::RecentFilter::Info cppInfo;
-    cppInfo.contains = (Gtk::RecentFilterFlags)filter_info->contains;
-    cppInfo.uri = Glib::convert_const_gchar_ptr_to_ustring(filter_info->uri);
-    cppInfo.display_name = Glib::convert_const_gchar_ptr_to_ustring(filter_info->display_name);
-    cppInfo.mime_type = Glib::convert_const_gchar_ptr_to_ustring(filter_info->mime_type);
-    
-    // Create string lists from char**s.
-    
-    for(int i = 0; filter_info->groups[i] != 0; ++i)
-    {
-      cppInfo.groups.push_back( Glib::convert_const_gchar_ptr_to_ustring(filter_info->groups[i]) );
-    }
-    for(int i = 0; filter_info->applications[i] != 0; ++i)
-    {
-      cppInfo.applications.push_back( Glib::convert_const_gchar_ptr_to_ustring(filter_info->applications[i]) );
-    }
-    
-    cppInfo.age = filter_info->age;
-  
-    return (*the_slot)(cppInfo);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-    return false; // arbitrary default;
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_Custom_gtk_callback_destroy(void* data)
-{
-  delete static_cast<Gtk::RecentFilter::SlotCustom*>(data);
-}
-
-namespace Gtk
-{
-
-RecentFilter::Info::Info()
-: contains(Gtk::RECENT_FILTER_MIME_TYPE), //arbitrary default
-  age(0)
-{
-}
-
-void RecentFilter::add_custom(RecentFilterFlags needed, const SlotCustom& slot)
-{
-  // Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  // It will be deleted when SignalProxy_Custom_gtk_callback_destroy() is called.
-  SlotCustom* slot_copy = new SlotCustom(slot);
-      
-  gtk_recent_filter_add_custom(gobj(), (GtkRecentFilterFlags)needed,
-                               &SignalProxy_Custom_gtk_callback,
-                               slot_copy,
-                               &SignalProxy_Custom_gtk_callback_destroy);
-}
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-// static
-GType Glib::Value<Gtk::RecentFilterFlags>::value_type()
-{
-  return gtk_recent_filter_flags_get_type();
-}
-
-
-namespace Glib
-{
-
-Gtk::RecentFilter* wrap(GtkRecentFilter* object, bool take_copy)
-{
-  return dynamic_cast<Gtk::RecentFilter *> (Glib::wrap_auto ((GObject*)(object), take_copy));
-}
-
-} /* namespace Glib */
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& RecentFilter_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_ = &RecentFilter_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(gtk_recent_filter_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void RecentFilter_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* RecentFilter_Class::wrap_new(GObject* o)
-{
-  return manage(new RecentFilter((GtkRecentFilter*)(o)));
-
-}
-
-
-/* The implementation: */
-
-RecentFilter::RecentFilter(const Glib::ConstructParams& construct_params)
-:
-  Gtk::Object(construct_params)
-{
-  }
-
-RecentFilter::RecentFilter(GtkRecentFilter* castitem)
-:
-  Gtk::Object((GtkObject*)(castitem))
-{
-  }
-
-RecentFilter::~RecentFilter()
-{
-  destroy_();
-}
-
-RecentFilter::CppClassType RecentFilter::recentfilter_class_; // initialize static member
-
-GType RecentFilter::get_type()
-{
-  return recentfilter_class_.init().get_type();
-}
-
-GType RecentFilter::get_base_type()
-{
-  return gtk_recent_filter_get_type();
-}
-
-
-RecentFilter::RecentFilter()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Object(Glib::ConstructParams(recentfilter_class_.init()))
-{
-  }
-
-void RecentFilter::set_name(const Glib::ustring& name)
-{
-gtk_recent_filter_set_name(gobj(), name.c_str()); 
-}
-
-Glib::ustring RecentFilter::get_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_recent_filter_get_name(const_cast<GtkRecentFilter*>(gobj())));
-}
-
-void RecentFilter::add_mime_type(const Glib::ustring& mime_type)
-{
-gtk_recent_filter_add_mime_type(gobj(), mime_type.c_str()); 
-}
-
-void RecentFilter::add_pattern(const Glib::ustring& pattern)
-{
-gtk_recent_filter_add_pattern(gobj(), pattern.c_str()); 
-}
-
-void RecentFilter::add_pixbuf_formats()
-{
-gtk_recent_filter_add_pixbuf_formats(gobj()); 
-}
-
-void RecentFilter::add_application(const Glib::ustring& application)
-{
-gtk_recent_filter_add_application(gobj(), application.c_str()); 
-}
-
-void RecentFilter::add_group(const Glib::ustring& group)
-{
-gtk_recent_filter_add_group(gobj(), group.c_str()); 
-}
-
-void RecentFilter::add_age(int days)
-{
-gtk_recent_filter_add_age(gobj(), days); 
-}
-
-RecentFilterFlags RecentFilter::get_needed() const
-{
-  return (RecentFilterFlags)gtk_recent_filter_get_needed(const_cast<GtkRecentFilter*>(gobj()));
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentfilter.h b/libs/gtkmm2/gtk/gtkmm/recentfilter.h
deleted file mode 100644
index 6f45077370..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentfilter.h
+++ /dev/null
@@ -1,270 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTFILTER_H
-#define _GTKMM_RECENTFILTER_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkRecentFilter GtkRecentFilter;
-typedef struct _GtkRecentFilterClass GtkRecentFilterClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class RecentFilter_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** @addtogroup gtkmmEnums Enums and Flags */
-
-/**
- * @ingroup gtkmmEnums
- * @par Bitwise operators:
- * <tt>%RecentFilterFlags operator|(RecentFilterFlags, RecentFilterFlags)</tt><br>
- * <tt>%RecentFilterFlags operator&(RecentFilterFlags, RecentFilterFlags)</tt><br>
- * <tt>%RecentFilterFlags operator^(RecentFilterFlags, RecentFilterFlags)</tt><br>
- * <tt>%RecentFilterFlags operator~(RecentFilterFlags)</tt><br>
- * <tt>%RecentFilterFlags& operator|=(RecentFilterFlags&, RecentFilterFlags)</tt><br>
- * <tt>%RecentFilterFlags& operator&=(RecentFilterFlags&, RecentFilterFlags)</tt><br>
- * <tt>%RecentFilterFlags& operator^=(RecentFilterFlags&, RecentFilterFlags)</tt><br>
- */
-enum RecentFilterFlags
-{
-  RECENT_FILTER_URI = 1 << 0,
-  RECENT_FILTER_DISPLAY_NAME = 1 << 1,
-  RECENT_FILTER_MIME_TYPE = 1 << 2,
-  RECENT_FILTER_APPLICATION = 1 << 3,
-  RECENT_FILTER_GROUP = 1 << 4,
-  RECENT_FILTER_AGE = 1 << 5
-};
-
-/** @ingroup gtkmmEnums */
-inline RecentFilterFlags operator|(RecentFilterFlags lhs, RecentFilterFlags rhs)
-  { return static_cast<RecentFilterFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
-
-/** @ingroup gtkmmEnums */
-inline RecentFilterFlags operator&(RecentFilterFlags lhs, RecentFilterFlags rhs)
-  { return static_cast<RecentFilterFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
-
-/** @ingroup gtkmmEnums */
-inline RecentFilterFlags operator^(RecentFilterFlags lhs, RecentFilterFlags rhs)
-  { return static_cast<RecentFilterFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
-
-/** @ingroup gtkmmEnums */
-inline RecentFilterFlags operator~(RecentFilterFlags flags)
-  { return static_cast<RecentFilterFlags>(~static_cast<unsigned>(flags)); }
-
-/** @ingroup gtkmmEnums */
-inline RecentFilterFlags& operator|=(RecentFilterFlags& lhs, RecentFilterFlags rhs)
-  { return (lhs = static_cast<RecentFilterFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
-
-/** @ingroup gtkmmEnums */
-inline RecentFilterFlags& operator&=(RecentFilterFlags& lhs, RecentFilterFlags rhs)
-  { return (lhs = static_cast<RecentFilterFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
-
-/** @ingroup gtkmmEnums */
-inline RecentFilterFlags& operator^=(RecentFilterFlags& lhs, RecentFilterFlags rhs)
-  { return (lhs = static_cast<RecentFilterFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::RecentFilterFlags> : public Glib::Value_Flags<Gtk::RecentFilterFlags>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** RecentFilter can be used to restrict the files being shown
- * in a RecentChooser.  Files can be filtered based on their name
- * (with add_pattern()), on their mime type (with add_mime_type()),
- * on the application that has registered them (with add_application()),
- * or by a custom filter function (with add_custom()).
- *
- * Filtering by mime type handles aliasing and subclassing of mime
- * types; e.g. a filter for text/plain also matches a file with mime
- * type application/rtf, since application/rtf is a subclass of text/plain.
- * Note that RecentFilter allows wildcards for the subtype of a
- * mime type, so you can e.g. filter for image/ *.
- *
- * Normally, filters are used by adding them to a RecentChooser,
- * see RecentChooser::add_filter(), but it is also possible to
- * manually use a filter on a file with filter().
- *
- * @newin2p10
- *
- * @ingroup RecentFiles
- */
-
-class RecentFilter : public Gtk::Object
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentFilter CppObjectType;
-  typedef RecentFilter_Class CppClassType;
-  typedef GtkRecentFilter BaseObjectType;
-  typedef GtkRecentFilterClass BaseClassType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-  virtual ~RecentFilter();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-private:
-  friend class RecentFilter_Class;
-  static CppClassType recentfilter_class_;
-
-  // noncopyable
-  RecentFilter(const RecentFilter&);
-  RecentFilter& operator=(const RecentFilter&);
-
-protected:
-  explicit RecentFilter(const Glib::ConstructParams& construct_params);
-  explicit RecentFilter(GtkRecentFilter* 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.
-  GtkRecentFilter*       gobj()       { return reinterpret_cast<GtkRecentFilter*>(gobject_); }
-
-  ///Provides access to the underlying C GtkObject.
-  const GtkRecentFilter* gobj() const { return reinterpret_cast<GtkRecentFilter*>(gobject_); }
-
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-private:
-
-public:
-  RecentFilter();
-
-  
-  void set_name(const Glib::ustring& name);
-  
-  Glib::ustring get_name() const;
-
-  
-  void add_mime_type(const Glib::ustring& mime_type);
-  
-  void add_pattern(const Glib::ustring& pattern);
-  
-  void add_pixbuf_formats();
-  
-  void add_application(const Glib::ustring& application);
-  
-  void add_group(const Glib::ustring& group);
-  
-  void add_age(int days);
-
-  /** A RecentFilter::Info class is used to pass information
-   * about the tested file to filter().
-   *
-   * - contains: Flags indicating which of the following fields need are filled
-   * - uri: the URI of the file being tested
-   * - display_name: the string that will be used to display the file in the recent chooser
-   * - mime_type: the mime type of the file
-   * - applications: the list of applications that have registered the file
-   * - groups: the groups to which the file belongs to
-   * - age: the number of days elapsed since the file has been registered
-   */
-  class Info
-  {
-  public:
-    Info();
-
-    ///This bitmask tells us which of the other variables contain useful information.
-    RecentFilterFlags contains;
-
-    Glib::ustring uri;
-    Glib::ustring display_name;
-    Glib::ustring mime_type;
-    std::list<Glib::ustring> applications;
-    std::list<Glib::ustring> groups;
-    int age;
-  };
-
-  /// For instance, bool on_custom(const Gtk::RecentFilter::Info& filter_info);
-  typedef sigc::slot<bool, const Info&> SlotCustom;
-  
-  void add_custom(RecentFilterFlags needed, const SlotCustom& slot);
-  
-
-  RecentFilterFlags get_needed() const;
-
-  // Method is used by class RecentChooser implementors.
-  
-  //_WRAP_METHOD(bool filter(const GtkRecentFilterInfo* filter_info), gtk_recent_filter_filter)
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::RecentFilter
-   * @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.
-   */
-  Gtk::RecentFilter* wrap(GtkRecentFilter* object, bool take_copy = false);
-} //namespace Glib
-
-
-#endif /* _GTKMM_RECENTFILTER_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentinfo.cc b/libs/gtkmm2/gtk/gtkmm/recentinfo.cc
deleted file mode 100644
index 0605127200..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentinfo.cc
+++ /dev/null
@@ -1,238 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/recentinfo.h>
-#include <gtkmm/private/recentinfo_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkrecentmanager.h>
-
-namespace Gtk
-{
-
-bool RecentInfo::equal(const RecentInfo& other) const
-{
-  return (static_cast<bool>(gtk_recent_info_match(const_cast<GtkRecentInfo*>(this->gobj()),
-                                                  const_cast<GtkRecentInfo*>(other.gobj()))));
-}
-
-RecentInfo::operator bool() const
-{
-  return gobj() != 0;
-}
-
-Glib::StringArrayHandle RecentInfo::get_applications() const
-{
-  //We pass 0 for the length output argument, because we don't need it, because the returned array is null-terminated.
-  return Glib::StringArrayHandle(gtk_recent_info_get_applications(const_cast<GtkRecentInfo*>(this->gobj()), 0));
-}
-
-Glib::StringArrayHandle RecentInfo::get_groups() const
-{
-  //We pass 0 for the length output argument, because we don't need it, because the returned array is null-terminated.
-  return Glib::StringArrayHandle(gtk_recent_info_get_groups(const_cast<GtkRecentInfo*>(this->gobj()), 0));
-}
-
-RecentInfoTraits::CppType RecentInfoTraits::to_cpp_type(const CType& obj)
-{
-  return Glib::wrap(const_cast<CTypeNonConst>(obj), true);
-}
-
-} // namespace Gtk
-
-namespace
-{
-} // anonymous namespace
-
-
-/* Why reinterpret_cast<RecentInfo*>(gobject) is needed:
- *
- * A RecentInfo instance is in fact always a GtkRecentInfo instance.
- * Unfortunately, GtkRecentInfo cannot be a member of RecentInfo,
- * 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 RecentInfo 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<Gtk::RecentInfo> wrap(GtkRecentInfo* object, bool take_copy)
-{
-  if(take_copy && object)
-    gtk_recent_info_ref(object);
-
-  // See the comment at the top of this file, if you want to know why the cast works.
-  return Glib::RefPtr<Gtk::RecentInfo>(reinterpret_cast<Gtk::RecentInfo*>(object));
-}
-
-} // namespace Glib
-
-
-namespace Gtk
-{
-
-
-void RecentInfo::reference() const
-{
-  // See the comment at the top of this file, if you want to know why the cast works.
-  gtk_recent_info_ref(reinterpret_cast<GtkRecentInfo*>(const_cast<RecentInfo*>(this)));
-}
-
-void RecentInfo::unreference() const
-{
-  // See the comment at the top of this file, if you want to know why the cast works.
-  gtk_recent_info_unref(reinterpret_cast<GtkRecentInfo*>(const_cast<RecentInfo*>(this)));
-}
-
-GtkRecentInfo* RecentInfo::gobj()
-{
-  // See the comment at the top of this file, if you want to know why the cast works.
-  return reinterpret_cast<GtkRecentInfo*>(this);
-}
-
-const GtkRecentInfo* RecentInfo::gobj() const
-{
-  // See the comment at the top of this file, if you want to know why the cast works.
-  return reinterpret_cast<const GtkRecentInfo*>(this);
-}
-
-GtkRecentInfo* RecentInfo::gobj_copy() const
-{
-  // See the comment at the top of this file, if you want to know why the cast works.
-  GtkRecentInfo *const gobject = reinterpret_cast<GtkRecentInfo*>(const_cast<RecentInfo*>(this));
-  gtk_recent_info_ref(gobject);
-  return gobject;
-}
-
-
-Glib::ustring RecentInfo::get_uri() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_recent_info_get_uri(const_cast<GtkRecentInfo*>(gobj())));
-}
-
-Glib::ustring RecentInfo::get_display_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_recent_info_get_display_name(const_cast<GtkRecentInfo*>(gobj())));
-}
-
-Glib::ustring RecentInfo::get_description() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_recent_info_get_description(const_cast<GtkRecentInfo*>(gobj())));
-}
-
-Glib::ustring RecentInfo::get_mime_type() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_recent_info_get_mime_type(const_cast<GtkRecentInfo*>(gobj())));
-}
-
-time_t RecentInfo::get_added() const
-{
-  return gtk_recent_info_get_added(const_cast<GtkRecentInfo*>(gobj()));
-}
-
-time_t RecentInfo::get_modified() const
-{
-  return gtk_recent_info_get_modified(const_cast<GtkRecentInfo*>(gobj()));
-}
-
-time_t RecentInfo::get_visited() const
-{
-  return gtk_recent_info_get_visited(const_cast<GtkRecentInfo*>(gobj()));
-}
-
-bool RecentInfo::get_private_hint() const
-{
-  return gtk_recent_info_get_private_hint(const_cast<GtkRecentInfo*>(gobj()));
-}
-
-bool RecentInfo::get_application_info(const Glib::ustring& app_name, Glib::StringArrayHandle& app_exec, guint& count, time_t& time) const
-{
-  return gtk_recent_info_get_application_info(const_cast<GtkRecentInfo*>(gobj()), app_name.c_str(), const_cast<gchar**>((app_exec).data()), &(count), &(time));
-}
-
-Glib::ustring RecentInfo::last_application() const
-{
-  return Glib::convert_return_gchar_ptr_to_ustring(gtk_recent_info_last_application(const_cast<GtkRecentInfo*>(gobj())));
-}
-
-bool RecentInfo::has_application(const Glib::ustring& app_name) const
-{
-  return gtk_recent_info_has_application(const_cast<GtkRecentInfo*>(gobj()), app_name.c_str());
-}
-
-bool RecentInfo::has_group(const Glib::ustring& group) const
-{
-  return gtk_recent_info_has_group(const_cast<GtkRecentInfo*>(gobj()), group.c_str());
-}
-
-Glib::RefPtr<Gdk::Pixbuf> RecentInfo::get_icon(int size)
-{
-
-  Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_recent_info_get_icon(gobj(), size));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const Gdk::Pixbuf> RecentInfo::get_icon(int size) const
-{
-
-  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_recent_info_get_icon(const_cast<GtkRecentInfo*>(gobj()), size));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::ustring RecentInfo::get_short_name() const
-{
-  return Glib::convert_return_gchar_ptr_to_ustring(gtk_recent_info_get_short_name(const_cast<GtkRecentInfo*>(gobj())));
-}
-
-Glib::ustring RecentInfo::get_uri_display() const
-{
-  return Glib::convert_return_gchar_ptr_to_ustring(gtk_recent_info_get_uri_display(const_cast<GtkRecentInfo*>(gobj())));
-}
-
-int RecentInfo::get_age() const
-{
-  return gtk_recent_info_get_age(const_cast<GtkRecentInfo*>(gobj()));
-}
-
-bool RecentInfo::is_local() const
-{
-  return gtk_recent_info_is_local(const_cast<GtkRecentInfo*>(gobj()));
-}
-
-bool RecentInfo::exists() const
-{
-  return gtk_recent_info_exists(const_cast<GtkRecentInfo*>(gobj()));
-}
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentinfo.h b/libs/gtkmm2/gtk/gtkmm/recentinfo.h
deleted file mode 100644
index 0ba088a6a3..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentinfo.h
+++ /dev/null
@@ -1,186 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTINFO_H
-#define _GTKMM_RECENTINFO_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <time.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkRecentInfo GtkRecentInfo;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
-
-namespace Gtk
-{
-
-
-/** Contains informations found when looking up an entry of the
- * recently used files list.
- *
- * @newin2p10
- *
- * @ingroup RecentFiles
- */
-class RecentInfo
-{
-  public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef RecentInfo CppObjectType;
-  typedef GtkRecentInfo BaseObjectType;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-  // For use with Glib::RefPtr<> only.
-  void reference()   const;
-  void unreference() const;
-
-  ///Provides access to the underlying C instance.
-  GtkRecentInfo*       gobj();
-
-  ///Provides access to the underlying C instance.
-  const GtkRecentInfo* gobj() const;
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkRecentInfo* gobj_copy() const;
-
-protected:
-  // Do not derive this.  Gtk::RecentInfo can neither be constructed nor deleted.
-  RecentInfo();
-  void operator delete(void*, size_t);
-
-private:
-  // noncopyable
-  RecentInfo(const RecentInfo&);
-  RecentInfo& operator=(const RecentInfo&);
-
-
-public:
-
-  bool equal(const RecentInfo& other) const;
-  /// Tests whether the RecentInfo is valid.
-  operator bool() const;
-
-  
-  Glib::ustring get_uri() const;
-  
-  Glib::ustring get_display_name() const;
-  
-  Glib::ustring get_description() const;
-  
-  Glib::ustring get_mime_type() const;
-  
-  
-  time_t get_added() const;
-  
-  time_t get_modified() const;
-  
-  time_t get_visited() const;
-  
-  
-  bool get_private_hint() const;
-
-  
-  bool get_application_info(const Glib::ustring& app_name, Glib::StringArrayHandle& app_exec, guint& count, time_t& time) const;
-  Glib::StringArrayHandle get_applications() const;
-  
-  //_WRAP_METHOD(Glib::StringArrayHandle get_applications(unsigned& length) const, gtk_recent_info_get_applications)
-  
-  Glib::ustring last_application() const;
-  
-  bool has_application(const Glib::ustring& app_name) const;
-  
-  Glib::StringArrayHandle get_groups() const;
-  
-  //_WRAP_METHOD(Glib::StringArrayHandle get_groups(unsigned& length) const, gtk_recent_info_get_groups)
-  
-  bool has_group(const Glib::ustring& group) const;
-  
-  
-  Glib::RefPtr<Gdk::Pixbuf> get_icon(int size);
-  
-  Glib::RefPtr<const Gdk::Pixbuf> get_icon(int size) const;
-  
-  
-  Glib::ustring get_short_name() const;
-  
-  Glib::ustring get_uri_display() const;
-  
-  
-  int get_age() const;
-  
-  bool is_local() const;
-  
-  bool exists() const;
-
-  
-  //_WRAP_METHOD(bool match(const RecentInfo& b) const, gtk_recent_info_match)
-
-
-};
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-struct RecentInfoTraits
-{
-  typedef Glib::RefPtr<RecentInfo> CppType;
-  typedef const GtkRecentInfo* CType;
-  typedef GtkRecentInfo* CTypeNonConst;
-
-  static CType to_c_type(const CppType& obj) { return Glib::unwrap(obj); }
-  static CType to_c_type(const CType& obj) { return obj; }
-  static CppType to_cpp_type(const CType& obj); //Implemented in the .cpp file
-  static void release_c_type(const CType& /* obj */) { /* gtk_recent_info_unref(const_cast<CTypeNonConst>(obj)); */}
-};
-#endif
-
-//TODO: We normally put these inside the class:
-
-/** @relates Gtk::RecentInfo */
-inline bool operator==(const RecentInfo& lhs, const RecentInfo& rhs)
-  { return lhs.equal(rhs); }
-
-/** @relates Gtk::RecentInfo */
-inline bool operator!=(const RecentInfo& lhs, const RecentInfo& rhs)
-  { return !lhs.equal(rhs); }
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-
-  /** @relates Gtk::RecentInfo
-   * @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<Gtk::RecentInfo> wrap(GtkRecentInfo* object, bool take_copy = false);
-
-} // namespace Glib
-
-
-#endif /* _GTKMM_RECENTINFO_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentmanager.cc b/libs/gtkmm2/gtk/gtkmm/recentmanager.cc
deleted file mode 100644
index 5709b36495..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentmanager.cc
+++ /dev/null
@@ -1,458 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/recentmanager.h>
-#include <gtkmm/private/recentmanager_p.h>
-
-/* Copyright (C) 2006 The gtkmm 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 <gtk/gtkrecentmanager.h>
-#include <gtk/gtktypebuiltins.h>
-
-namespace Gtk
-{
-
-//Allow the generated code to work without the prefix:
-typedef RecentManager::ListHandle_RecentInfos ListHandle_RecentInfos;
-
-} //namespace Gtk
-
-namespace
-{
-
-
-static const Glib::SignalProxyInfo RecentManager_signal_changed_info =
-{
-  "changed",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
-} // anonymous namespace
-
-
-Gtk::RecentManagerError::RecentManagerError(Gtk::RecentManagerError::Code error_code, const Glib::ustring& error_message)
-:
-  Glib::Error (GTK_RECENT_MANAGER_ERROR, error_code, error_message)
-{}
-
-Gtk::RecentManagerError::RecentManagerError(GError* gobject)
-:
-  Glib::Error (gobject)
-{}
-
-Gtk::RecentManagerError::Code Gtk::RecentManagerError::code() const
-{
-  return static_cast<Code>(Glib::Error::code());
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-void Gtk::RecentManagerError::throw_func(GError* gobject)
-{
-  throw Gtk::RecentManagerError(gobject);
-}
-#else
-//When not using exceptions, we just pass the Exception object around without throwing it:
-std::auto_ptr<Glib::Error> Gtk::RecentManagerError::throw_func(GError* gobject)
-{
-  return std::auto_ptr<Glib::Error>(new Gtk::RecentManagerError(gobject));
-}
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-// static
-GType Glib::Value<Gtk::RecentManagerError::Code>::value_type()
-{
-  return gtk_recent_manager_error_get_type();
-}
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::RecentManager> wrap(GtkRecentManager* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::RecentManager>( dynamic_cast<Gtk::RecentManager*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& RecentManager_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_ = &RecentManager_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(gtk_recent_manager_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void RecentManager_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->changed = &changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void RecentManager_Class::changed_callback(GtkRecentManager* 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->changed)
-      (*base->changed)(self);
-  }
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* RecentManager_Class::wrap_new(GObject* object)
-{
-  return new RecentManager((GtkRecentManager*)object);
-}
-
-
-/* The implementation: */
-
-GtkRecentManager* RecentManager::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-RecentManager::RecentManager(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-RecentManager::RecentManager(GtkRecentManager* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-RecentManager::~RecentManager()
-{}
-
-
-RecentManager::CppClassType RecentManager::recentmanager_class_; // initialize static member
-
-GType RecentManager::get_type()
-{
-  return recentmanager_class_.init().get_type();
-}
-
-GType RecentManager::get_base_type()
-{
-  return gtk_recent_manager_get_type();
-}
-
-
-RecentManager::RecentManager()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(recentmanager_class_.init()))
-{
-  }
-
-Glib::RefPtr<RecentManager> RecentManager::create()
-{
-  return Glib::RefPtr<RecentManager>( new RecentManager() );
-}
-Glib::RefPtr<RecentManager> RecentManager::get_default()
-{
-
-  Glib::RefPtr<RecentManager> retvalue = Glib::wrap(gtk_recent_manager_get_default());
-
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-}
-
-
-Glib::RefPtr<RecentManager> RecentManager::get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen)
-{
-
-  Glib::RefPtr<RecentManager> retvalue = Glib::wrap(gtk_recent_manager_get_for_screen(Glib::unwrap(screen)));
-
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-}
-
-
-void RecentManager::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
-{
-gtk_recent_manager_set_screen(gobj(), Glib::unwrap(screen)); 
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-bool RecentManager::add_item(const Glib::ustring& uri)
-#else
-bool RecentManager::add_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_recent_manager_add_item(gobj(), uri.c_str());
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-bool RecentManager::add_item(const Glib::ustring& uri, const Data& recent_data)
-{
-  return gtk_recent_manager_add_full(gobj(), uri.c_str(), (GtkRecentData*)(&(recent_data)));
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-bool RecentManager::remove_item(const Glib::ustring& uri)
-#else
-bool RecentManager::remove_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_recent_manager_remove_item(gobj(), uri.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<RecentInfo> RecentManager::lookup_item(const Glib::ustring& uri)
-#else
-Glib::RefPtr<RecentInfo> RecentManager::lookup_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Glib::RefPtr<RecentInfo> retvalue = Glib::wrap(gtk_recent_manager_lookup_item(gobj(), uri.c_str(), &(gerror)));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<const RecentInfo> RecentManager::lookup_item(const Glib::ustring& uri) const
-#else
-Glib::RefPtr<const RecentInfo> RecentManager::lookup_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error) const
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  Glib::RefPtr<const RecentInfo> retvalue = Glib::wrap(gtk_recent_manager_lookup_item(const_cast<GtkRecentManager*>(gobj()), uri.c_str(), &(gerror)));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-bool RecentManager::has_item(const Glib::ustring& uri) const
-{
-  return gtk_recent_manager_has_item(const_cast<GtkRecentManager*>(gobj()), uri.c_str());
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-bool RecentManager::move_item(const Glib::ustring& uri, const Glib::ustring& new_uri)
-#else
-bool RecentManager::move_item(const Glib::ustring& uri, const Glib::ustring& new_uri, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_recent_manager_move_item(gobj(), uri.c_str(), new_uri.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-void RecentManager::set_limit(int limit)
-{
-gtk_recent_manager_set_limit(gobj(), limit); 
-}
-
-int RecentManager::get_limit() const
-{
-  return gtk_recent_manager_get_limit(const_cast<GtkRecentManager*>(gobj()));
-}
-
-ListHandle_RecentInfos RecentManager::get_items() const
-{
-  return ListHandle_RecentInfos(gtk_recent_manager_get_items(const_cast<GtkRecentManager*>(gobj())), Glib::OWNERSHIP_SHALLOW);
-}
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-int RecentManager::purge_items()
-#else
-int RecentManager::purge_items(std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  int retvalue = gtk_recent_manager_purge_items(gobj(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  return retvalue;
-
-}
-
-
-Glib::SignalProxy0< void > RecentManager::signal_changed()
-{
-  return Glib::SignalProxy0< void >(this, &RecentManager_signal_changed_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> RecentManager::property_filename() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "filename");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<int> RecentManager::property_limit() 
-{
-  return Glib::PropertyProxy<int>(this, "limit");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> RecentManager::property_limit() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "limit");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> RecentManager::property_size() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "size");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-void Gtk::RecentManager::on_changed()
-{
-  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->changed)
-    (*base->changed)(gobj());
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/recentmanager.h b/libs/gtkmm2/gtk/gtkmm/recentmanager.h
deleted file mode 100644
index c48ffffd2f..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/recentmanager.h
+++ /dev/null
@@ -1,363 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_RECENTMANAGER_H
-#define _GTKMM_RECENTMANAGER_H
-
-
-#include <glibmm.h>
-
-/* Copyright (C) 2006 The gtkmm 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/screen.h>
-#include <gdkmm/pixbuf.h>
-
-#include <gtkmm/recentinfo.h>
-
-#include <glibmm/object.h>
-#include <glibmm/containers.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkRecentManager GtkRecentManager;
-typedef struct _GtkRecentManagerClass GtkRecentManagerClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class RecentManager_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** Exception class for Gtk::RecentManager errors.
- */
-class RecentManagerError : public Glib::Error
-{
-public:
-  enum Code
-  {
-    NOT_FOUND,
-    INVALID_URI,
-    INVALID_ENCODING,
-    NOT_REGISTERED,
-    READ,
-    WRITE,
-    UNKNOWN
-  };
-
-  RecentManagerError(Code error_code, const Glib::ustring& error_message);
-  explicit RecentManagerError(GError* gobject);
-  Code code() const;
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-private:
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  static void throw_func(GError* gobject);
-#else
-  //When not using exceptions, we just pass the Exception object around without throwing it:
-  static std::auto_ptr<Glib::Error> throw_func(GError* gobject);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  friend void wrap_init(); // uses throw_func()
-#endif
-};
-
-} // namespace Gtk
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::RecentManagerError::Code> : public Glib::Value_Enum<Gtk::RecentManagerError::Code>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
-
-/** @defgroup RecentFiles RecentFiles
- */
-
-/** RecentManager provides a facility for adding, removing and
- * looking up recently used files.  Each recently used file is
- * identified by its URI, and has meta-data associated to it, like
- * the names and command lines of the applications that have
- * registered it, the number of time each application has registered
- * the same file, the mime type of the file and whether the file
- * should be displayed only by the applications that have
- * registered it.
- *
- * The RecentManager acts like a database of all the recently
- * used files.  You can create new RecentManager objects, but
- * it is more efficient to use the standard recent manager for
- * the Gdk::Screen so that informations about the recently used
- * files is shared with other people using them. Normally, you
- * retrieve the recent manager for a particular screen using
- * get_for_screen() and it will contain information about current
- * recent manager for that screen.
- *
- * @newin2p10
- *
- * @ingroup RecentFiles
- */
-
-class RecentManager : public Glib::Object
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef RecentManager CppObjectType;
-  typedef RecentManager_Class CppClassType;
-  typedef GtkRecentManager BaseObjectType;
-  typedef GtkRecentManagerClass BaseClassType;
-
-private:  friend class RecentManager_Class;
-  static CppClassType recentmanager_class_;
-
-private:
-  // noncopyable
-  RecentManager(const RecentManager&);
-  RecentManager& operator=(const RecentManager&);
-
-protected:
-  explicit RecentManager(const Glib::ConstructParams& construct_params);
-  explicit RecentManager(GtkRecentManager* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~RecentManager();
-
-#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 GObject.
-  GtkRecentManager*       gobj()       { return reinterpret_cast<GtkRecentManager*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkRecentManager* gobj() const { return reinterpret_cast<GtkRecentManager*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkRecentManager* gobj_copy();
-
-private:
-
-
-protected:
-  RecentManager();
-
-public:
-  
-  static Glib::RefPtr<RecentManager> create();
-
-
-  static Glib::RefPtr<RecentManager> get_default();
-  
-  static Glib::RefPtr<RecentManager> get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen);
-
-  /** Meta-data passed to add_item().  You should
-   * use RecentManager::Data if you want to control the meta-data associated
-   * to an entry of the recently used files list when you are adding
-   * a new file to it.
-   *
-   * - display_name: the string to be used when displaying the file inside a RecentChooser
-   * - description: a user readable description of the file
-   * - mime_type: the mime type of the file
-   * - app_name: the name of the application that is registering the file
-   * - app_exec: the command line that should be used when launching the file
-   * - groups: the list of group names to which the file belongs to
-   * - is_private: whether the file should be displayed only by the applications that have registered it
-  */
-  class Data
-  { 
-  public:
-    Glib::ustring display_name;
-    Glib::ustring description;
-    
-    Glib::ustring mime_type;
-    
-    Glib::ustring app_name;
-    Glib::ustring app_exec;
-    
-    Glib::StringArrayHandle groups;
-  
-    bool is_private;
-  };
-
- 
-  void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  bool add_item(const Glib::ustring& uri);
-#else
-  bool add_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-  bool add_item(const Glib::ustring& uri, const Data& recent_data);
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  bool remove_item(const Glib::ustring& uri);
-#else
-  bool remove_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::RefPtr<RecentInfo> lookup_item(const Glib::ustring& uri);
-#else
-  Glib::RefPtr<RecentInfo> lookup_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::RefPtr<const RecentInfo> lookup_item(const Glib::ustring& uri) const;
-#else
-  Glib::RefPtr<const RecentInfo> lookup_item(const Glib::ustring& uri, std::auto_ptr<Glib::Error>& error) const;
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-  bool has_item(const Glib::ustring& uri) const;
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  bool move_item(const Glib::ustring& uri, const Glib::ustring& new_uri);
-#else
-  bool move_item(const Glib::ustring& uri, const Glib::ustring& new_uri, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-  
-  void set_limit(int limit);
-  
-  int get_limit() const;
-
-  typedef Glib::ListHandle<RecentInfo, RecentInfoTraits> ListHandle_RecentInfos;
-  
-
-  ListHandle_RecentInfos get_items() const;
-
-  
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  int purge_items();
-#else
-  int purge_items(std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
-
-  /// For instance, void on_changed();
-  typedef sigc::slot<void> SlotChanged;
-
-  /** The "changed" signal is emitted when an item in the recently used resources list is changed.
-  */
-  
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_changed();
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The full path to the file to be used to store and read the list.
-   *
-   * 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_filename() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The maximum number of items to be returned by gtk_recent_manager_get_items.
-   *
-   * 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_limit() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The maximum number of items to be returned by gtk_recent_manager_get_items.
-   *
-   * 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_limit() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The size of the recently used resources list.
-   *
-   * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual void on_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::RecentManager
-   * @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<Gtk::RecentManager> wrap(GtkRecentManager* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_RECENTMANAGER_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/ruler.cc b/libs/gtkmm2/gtk/gtkmm/ruler.cc
index f104c64455..0983eb0210 100644
--- a/libs/gtkmm2/gtk/gtkmm/ruler.cc
+++ b/libs/gtkmm2/gtk/gtkmm/ruler.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/ruler.h>
 #include <gtkmm/private/ruler_p.h>
 
@@ -94,16 +93,10 @@ void Ruler_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->draw_ticks = &draw_ticks_vfunc_callback;
   klass->draw_pos = &draw_pos_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Ruler_Class::draw_ticks_vfunc_callback(GtkRuler* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -116,19 +109,15 @@ void Ruler_Class::draw_ticks_vfunc_callback(GtkRuler* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_ticks_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -141,6 +130,7 @@ void Ruler_Class::draw_ticks_vfunc_callback(GtkRuler* self)
       (*base->draw_ticks)(self);
   }
 }
+
 void Ruler_Class::draw_pos_vfunc_callback(GtkRuler* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -153,19 +143,15 @@ void Ruler_Class::draw_pos_vfunc_callback(GtkRuler* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_pos_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -178,10 +164,6 @@ void Ruler_Class::draw_pos_vfunc_callback(GtkRuler* self)
       (*base->draw_pos)(self);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Ruler_Class::wrap_new(GObject* o)
@@ -232,7 +214,7 @@ Ruler::Ruler()
 
 void Ruler::set_metric(MetricType metric)
 {
-gtk_ruler_set_metric(gobj(), ((GtkMetricType)(metric))); 
+  gtk_ruler_set_metric(gobj(), ((GtkMetricType)(metric)));
 }
 
 MetricType Ruler::get_metric()
@@ -240,98 +222,78 @@ MetricType Ruler::get_metric()
   return ((MetricType)(gtk_ruler_get_metric(gobj())));
 }
 
- double Ruler::get_range_lower() const
+double Ruler::get_range_lower() const
 {
   return gobj()->lower;
 }
- 
- double Ruler::get_range_upper() const
+
+double Ruler::get_range_upper() const
 {
   return gobj()->upper;
 }
- 
+
 void Ruler::set_range(double lower, double upper, double position, double max_size)
 {
-gtk_ruler_set_range(gobj(), lower, upper, position, max_size); 
+  gtk_ruler_set_range(gobj(), lower, upper, position, max_size);
 }
 
 void Ruler::get_range(double& lower, double& upper, double& position, double& max_size)
 {
-gtk_ruler_get_range(gobj(), &(lower), &(upper), &(position), &(max_size)); 
+  gtk_ruler_get_range(gobj(), &(lower), &(upper), &(position), &(max_size));
 }
 
 void Ruler::draw_ticks()
 {
-gtk_ruler_draw_ticks(gobj()); 
+  gtk_ruler_draw_ticks(gobj());
 }
 
 void Ruler::draw_pos()
 {
-gtk_ruler_draw_pos(gobj()); 
+  gtk_ruler_draw_pos(gobj());
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Ruler::property_lower() 
 {
   return Glib::PropertyProxy<double>(this, "lower");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Ruler::property_lower() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "lower");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Ruler::property_upper() 
 {
   return Glib::PropertyProxy<double>(this, "upper");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Ruler::property_upper() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "upper");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Ruler::property_position() 
 {
   return Glib::PropertyProxy<double>(this, "position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Ruler::property_position() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Ruler::property_max_size() 
 {
   return Glib::PropertyProxy<double>(this, "max-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Ruler::property_max_size() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "max-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Gtk::Ruler::draw_ticks_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -341,6 +303,7 @@ void Gtk::Ruler::draw_ticks_vfunc()
   if(base && base->draw_ticks)
     (*base->draw_ticks)(gobj());
 }
+
 void Gtk::Ruler::draw_pos_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -350,7 +313,6 @@ void Gtk::Ruler::draw_pos_vfunc()
   if(base && base->draw_pos)
     (*base->draw_pos)(gobj());
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -397,19 +359,8 @@ void VRuler_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* VRuler_Class::wrap_new(GObject* o)
 {
@@ -457,13 +408,6 @@ VRuler::VRuler()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -508,19 +452,8 @@ void HRuler_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* HRuler_Class::wrap_new(GObject* o)
 {
@@ -568,13 +501,6 @@ HRuler::HRuler()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/ruler.h b/libs/gtkmm2/gtk/gtkmm/ruler.h
index 3afec185d1..510df8c7b4 100644
--- a/libs/gtkmm2/gtk/gtkmm/ruler.h
+++ b/libs/gtkmm2/gtk/gtkmm/ruler.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_RULER_H
 #define _GTKMM_RULER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -111,17 +110,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -148,9 +141,9 @@ public:
    */
   MetricType get_metric();
 
-   double get_range_lower() const;
-    double get_range_upper() const;
- 
+  double get_range_lower() const;
+  double get_range_upper() const;
+
   /** sets the range of the ruler.
    * <i>upper</i> and <i>lower</i> arguments denote the extents of the Ruler.
    * <i>max_size</i> is the largest number displayed by the ruler.
@@ -178,26 +171,17 @@ public:
   
   void draw_pos();
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_ticks_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_pos_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void draw_ticks_vfunc();
+    virtual void draw_pos_vfunc();
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Lower limit of ruler.
+  /** Lower limit of ruler.
    *
    * 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_lower() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Lower limit of ruler.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -205,19 +189,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_lower() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Upper limit of ruler.
+  /** Upper limit of ruler.
    *
    * 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_upper() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Upper limit of ruler.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -225,19 +205,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_upper() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Position of mark on the ruler.
+  /** Position of mark on the ruler.
    *
    * 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_position() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Position of mark on the ruler.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -245,19 +221,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Maximum size of the ruler.
+  /** Maximum size of the ruler.
    *
    * 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_max_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Maximum size of the ruler.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -265,7 +237,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_max_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -319,17 +290,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -389,17 +354,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -421,9 +380,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Ruler* wrap(GtkRuler* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::VRuler
@@ -432,9 +389,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::VRuler* wrap(GtkVRuler* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::HRuler
@@ -443,8 +398,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HRuler* wrap(GtkHRuler* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_RULER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/scale.cc b/libs/gtkmm2/gtk/gtkmm/scale.cc
index e3ca69c1f1..6b7042daa7 100644
--- a/libs/gtkmm2/gtk/gtkmm/scale.cc
+++ b/libs/gtkmm2/gtk/gtkmm/scale.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/scale.h>
 #include <gtkmm/private/scale_p.h>
 
@@ -121,8 +120,7 @@ HScale::HScale(Adjustment& adjustment)
 namespace
 {
 
-
-static gchar* Scale_signal_format_value_callback(GtkScale* self, gdouble p0,void* data)
+gchar* Scale_signal_format_value_callback(GtkScale* self, gdouble p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< Glib::ustring,double > SlotType;
@@ -130,28 +128,24 @@ static gchar* Scale_signal_format_value_callback(GtkScale* self, gdouble p0,void
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return (strlen((*static_cast<SlotType*>(slot))(p0
 ).c_str()) ? g_strdup((*static_cast<SlotType*>(slot))(p0
 ).c_str()) : 0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gchar* RType;
   return RType();
 }
 
-static gchar* Scale_signal_format_value_notify_callback(GtkScale* self, gdouble p0, void* data)
+gchar* Scale_signal_format_value_notify_callback(GtkScale* self, gdouble p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,double > SlotType;
@@ -159,34 +153,29 @@ static gchar* Scale_signal_format_value_notify_callback(GtkScale* self, gdouble
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gchar* RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Scale_signal_format_value_info =
+const Glib::SignalProxyInfo Scale_signal_format_value_info =
 {
   "format_value",
   (GCallback) &Scale_signal_format_value_callback,
   (GCallback) &Scale_signal_format_value_notify_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -231,16 +220,10 @@ void Scale_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->draw_value = &draw_value_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->format_value = &format_value_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Scale_Class::draw_value_vfunc_callback(GtkScale* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -253,19 +236,15 @@ void Scale_Class::draw_value_vfunc_callback(GtkScale* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_value_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -278,9 +257,8 @@ void Scale_Class::draw_value_vfunc_callback(GtkScale* self)
       (*base->draw_value)(self);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 gchar* Scale_Class::format_value_callback(GtkScale* self, gdouble p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -293,21 +271,17 @@ gchar* Scale_Class::format_value_callback(GtkScale* self, gdouble p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return (strlen(obj->on_format_value(p0
 ).c_str()) ? g_strdup(obj->on_format_value(p0
 ).c_str()) : 0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -323,7 +297,6 @@ gchar* Scale_Class::format_value_callback(GtkScale* self, gdouble p0)
   typedef gchar* RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Scale_Class::wrap_new(GObject* o)
@@ -374,7 +347,7 @@ Scale::Scale()
 
 void Scale::set_digits(int digits)
 {
-gtk_scale_set_digits(gobj(), digits); 
+  gtk_scale_set_digits(gobj(), digits);
 }
 
 int Scale::get_digits() const
@@ -384,7 +357,7 @@ int Scale::get_digits() const
 
 void Scale::set_draw_value(bool draw_value)
 {
-gtk_scale_set_draw_value(gobj(), static_cast<int>(draw_value)); 
+  gtk_scale_set_draw_value(gobj(), static_cast<int>(draw_value));
 }
 
 bool Scale::get_draw_value() const
@@ -394,7 +367,7 @@ bool Scale::get_draw_value() const
 
 void Scale::set_value_pos(PositionType pos)
 {
-gtk_scale_set_value_pos(gobj(), ((GtkPositionType)(pos))); 
+  gtk_scale_set_value_pos(gobj(), ((GtkPositionType)(pos)));
 }
 
 PositionType Scale::get_value_pos() const
@@ -406,20 +379,25 @@ Glib::RefPtr<Pango::Layout> Scale::get_layout()
 {
 
   Glib::RefPtr<Pango::Layout> retvalue = Glib::wrap(gtk_scale_get_layout(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Pango::Layout> Scale::get_layout() const
 {
-  return const_cast<Scale*>(this)->get_layout();
+
+  Glib::RefPtr<const Pango::Layout> retvalue = Glib::wrap(gtk_scale_get_layout(const_cast<GtkScale*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Scale::get_layout_offsets(int& x, int& y) const
 {
-gtk_scale_get_layout_offsets(const_cast<GtkScale*>(gobj()), &x, &y); 
+  gtk_scale_get_layout_offsets(const_cast<GtkScale*>(gobj()), &x, &y);
 }
 
 
@@ -429,50 +407,37 @@ Glib::SignalProxy1< Glib::ustring,double > Scale::signal_format_value()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Scale::property_digits() 
 {
   return Glib::PropertyProxy<int>(this, "digits");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Scale::property_digits() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "digits");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Scale::property_draw_value() 
 {
   return Glib::PropertyProxy<bool>(this, "draw-value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Scale::property_draw_value() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<PositionType> Scale::property_value_pos() 
 {
   return Glib::PropertyProxy<PositionType>(this, "value-pos");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<PositionType> Scale::property_value_pos() const
 {
   return Glib::PropertyProxy_ReadOnly<PositionType>(this, "value-pos");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 Glib::ustring Gtk::Scale::on_format_value(double value)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -485,9 +450,8 @@ Glib::ustring Gtk::Scale::on_format_value(double value)
   typedef Glib::ustring RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::Scale::draw_value_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -497,7 +461,6 @@ void Gtk::Scale::draw_value_vfunc()
   if(base && base->draw_value)
     (*base->draw_value)(gobj());
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
@@ -544,19 +507,8 @@ void VScale_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* VScale_Class::wrap_new(GObject* o)
 {
@@ -597,13 +549,6 @@ GType VScale::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -648,19 +593,8 @@ void HScale_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* HScale_Class::wrap_new(GObject* o)
 {
@@ -701,13 +635,6 @@ GType HScale::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/scale.h b/libs/gtkmm2/gtk/gtkmm/scale.h
index 3313552d20..fb4d39dbad 100644
--- a/libs/gtkmm2/gtk/gtkmm/scale.h
+++ b/libs/gtkmm2/gtk/gtkmm/scale.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SCALE_H
 #define _GTKMM_SCALE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -115,18 +114,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual Glib::ustring on_format_value(double value);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -176,7 +169,7 @@ public:
    * @return The Pango::Layout for this scale, or <tt>0</tt> if the draw_value property
    * is <tt>false</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<Pango::Layout> get_layout();
   
@@ -185,7 +178,7 @@ public:
    * @return The Pango::Layout for this scale, or <tt>0</tt> if the draw_value property
    * is <tt>false</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const Pango::Layout> get_layout() const;
   
@@ -197,7 +190,7 @@ public:
    * If the draw_value property is <tt>false</tt>, the return values are 
    * undefined.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param x Location to store X offset of layout, or <tt>0</tt>.
    * @param y Location to store Y offset of layout, or <tt>0</tt>.
    */
@@ -211,10 +204,6 @@ public:
    * as a double and should return the representation of it as a Glib::ustring.
    */ 
   
-/**
-   * @par Prototype:
-   * <tt>Glib::ustring %format_value(double value)</tt>
-   */
 
   Glib::SignalProxy1< Glib::ustring,double > signal_format_value();
 
@@ -224,17 +213,14 @@ public:
 
   /** Number of displayed decimal digits.
    */
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of decimal places that are displayed in the value.
+  /** The number of decimal places that are displayed in the value.
    *
    * 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_digits() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The number of decimal places that are displayed in the value.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -242,22 +228,18 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_digits() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   /** Whether to draw the value as a string next to slider.
    */
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the current value is displayed as a string next to the slider.
+  /** Whether the current value is displayed as a string next to the slider.
    *
    * 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_draw_value() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the current value is displayed as a string next to the slider.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -265,22 +247,18 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_draw_value() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   /** The position in which the value is displayed.
    */
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The position in which the current value is displayed.
+  /** The position in which the current value is displayed.
    *
    * 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<PositionType> property_value_pos() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The position in which the current value is displayed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -288,15 +266,11 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<PositionType> property_value_pos() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_value_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void draw_value_vfunc();
   
   virtual int calc_digits_(double step) const;
 
@@ -355,17 +329,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -436,17 +404,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -475,9 +437,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Scale* wrap(GtkScale* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::VScale
@@ -486,9 +446,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::VScale* wrap(GtkVScale* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::HScale
@@ -497,8 +455,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HScale* wrap(GtkHScale* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SCALE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/scrollbar.cc b/libs/gtkmm2/gtk/gtkmm/scrollbar.cc
index 5650494b98..1bf19b3cb8 100644
--- a/libs/gtkmm2/gtk/gtkmm/scrollbar.cc
+++ b/libs/gtkmm2/gtk/gtkmm/scrollbar.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/scrollbar.h>
 #include <gtkmm/private/scrollbar_p.h>
 
@@ -123,19 +122,8 @@ void Scrollbar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Scrollbar_Class::wrap_new(GObject* o)
 {
@@ -176,13 +164,6 @@ GType Scrollbar::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -227,19 +208,8 @@ void VScrollbar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* VScrollbar_Class::wrap_new(GObject* o)
 {
@@ -280,13 +250,6 @@ GType VScrollbar::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -331,19 +294,8 @@ void HScrollbar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* HScrollbar_Class::wrap_new(GObject* o)
 {
@@ -384,13 +336,6 @@ GType HScrollbar::get_base_type()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/scrollbar.h b/libs/gtkmm2/gtk/gtkmm/scrollbar.h
index e18a0243a0..36c7d1b8f8 100644
--- a/libs/gtkmm2/gtk/gtkmm/scrollbar.h
+++ b/libs/gtkmm2/gtk/gtkmm/scrollbar.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SCROLLBAR_H
 #define _GTKMM_SCROLLBAR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -116,17 +115,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -192,17 +185,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -269,17 +256,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -303,9 +284,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Scrollbar* wrap(GtkScrollbar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::VScrollbar
@@ -314,9 +293,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::VScrollbar* wrap(GtkVScrollbar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::HScrollbar
@@ -325,8 +302,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HScrollbar* wrap(GtkHScrollbar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SCROLLBAR_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/scrolledwindow.cc b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.cc
index 8319f9d821..aa297a6daa 100644
--- a/libs/gtkmm2/gtk/gtkmm/scrolledwindow.cc
+++ b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/scrolledwindow.h>
 #include <gtkmm/private/scrolledwindow_p.h>
 
@@ -101,19 +100,8 @@ void ScrolledWindow_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* ScrolledWindow_Class::wrap_new(GObject* o)
 {
@@ -170,22 +158,22 @@ ScrolledWindow::ScrolledWindow(Adjustment& hadjustment, Adjustment& vadjustment)
 
 void ScrolledWindow::set_hadjustment(Gtk::Adjustment* hadjustment)
 {
-gtk_scrolled_window_set_hadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(hadjustment)); 
+  gtk_scrolled_window_set_hadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(hadjustment));
 }
 
 void ScrolledWindow::set_vadjustment(Gtk::Adjustment* vadjustment)
 {
-gtk_scrolled_window_set_vadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(vadjustment)); 
+  gtk_scrolled_window_set_vadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(vadjustment));
 }
 
 void ScrolledWindow::set_hadjustment(Gtk::Adjustment& hadjustment)
 {
-gtk_scrolled_window_set_hadjustment(gobj(), (hadjustment).gobj()); 
+  gtk_scrolled_window_set_hadjustment(gobj(), (hadjustment).gobj());
 }
 
 void ScrolledWindow::set_vadjustment(Gtk::Adjustment& vadjustment)
 {
-gtk_scrolled_window_set_vadjustment(gobj(), (vadjustment).gobj()); 
+  gtk_scrolled_window_set_vadjustment(gobj(), (vadjustment).gobj());
 }
 
 Gtk::Adjustment* ScrolledWindow::get_hadjustment()
@@ -195,7 +183,7 @@ Gtk::Adjustment* ScrolledWindow::get_hadjustment()
 
 const Gtk::Adjustment* ScrolledWindow::get_hadjustment() const
 {
-  return const_cast<ScrolledWindow*>(this)->get_hadjustment();
+  return Glib::wrap(gtk_scrolled_window_get_hadjustment(const_cast<GtkScrolledWindow*>(gobj())));
 }
 
 Gtk::Adjustment* ScrolledWindow::get_vadjustment()
@@ -205,27 +193,22 @@ Gtk::Adjustment* ScrolledWindow::get_vadjustment()
 
 const Gtk::Adjustment* ScrolledWindow::get_vadjustment() const
 {
-  return const_cast<ScrolledWindow*>(this)->get_vadjustment();
+  return Glib::wrap(gtk_scrolled_window_get_vadjustment(const_cast<GtkScrolledWindow*>(gobj())));
 }
 
 void ScrolledWindow::set_policy(PolicyType hscrollbar_policy, PolicyType vscrollbar_policy)
 {
-gtk_scrolled_window_set_policy(gobj(), ((GtkPolicyType)(hscrollbar_policy)), ((GtkPolicyType)(vscrollbar_policy))); 
+  gtk_scrolled_window_set_policy(gobj(), ((GtkPolicyType)(hscrollbar_policy)), ((GtkPolicyType)(vscrollbar_policy)));
 }
 
 void ScrolledWindow::get_policy(PolicyType& hscrollbar_policy, PolicyType& vscrollbar_policy) const
 {
-gtk_scrolled_window_get_policy(const_cast<GtkScrolledWindow*>(gobj()), ((GtkPolicyType*) &(hscrollbar_policy)), ((GtkPolicyType*) &(vscrollbar_policy))); 
+  gtk_scrolled_window_get_policy(const_cast<GtkScrolledWindow*>(gobj()), ((GtkPolicyType*) &(hscrollbar_policy)), ((GtkPolicyType*) &(vscrollbar_policy)));
 }
 
 void ScrolledWindow::set_placement(CornerType window_placement)
 {
-gtk_scrolled_window_set_placement(gobj(), ((GtkCornerType)(window_placement))); 
-}
-
-void ScrolledWindow::unset_placement()
-{
-gtk_scrolled_window_unset_placement(gobj()); 
+  gtk_scrolled_window_set_placement(gobj(), ((GtkCornerType)(window_placement)));
 }
 
 CornerType ScrolledWindow::get_placement() const
@@ -235,7 +218,7 @@ CornerType ScrolledWindow::get_placement() const
 
 void ScrolledWindow::set_shadow_type(ShadowType type)
 {
-gtk_scrolled_window_set_shadow_type(gobj(), ((GtkShadowType)(type))); 
+  gtk_scrolled_window_set_shadow_type(gobj(), ((GtkShadowType)(type)));
 }
 
 ShadowType ScrolledWindow::get_shadow_type() const
@@ -243,127 +226,96 @@ ShadowType ScrolledWindow::get_shadow_type() const
   return ((ShadowType)(gtk_scrolled_window_get_shadow_type(const_cast<GtkScrolledWindow*>(gobj()))));
 }
 
-VScrollbar* ScrolledWindow::get_vscrollbar()
+bool ScrolledWindow::get_vscrollbar_visible() const
 {
-  return Glib::wrap((GtkVScrollbar*)gtk_scrolled_window_get_vscrollbar(gobj()));
+  return gobj()->hscrollbar_visible;
 }
 
-const VScrollbar* ScrolledWindow::get_vscrollbar() const
+bool ScrolledWindow::get_hscrollbar_visible() const
 {
-  return Glib::wrap((GtkVScrollbar*)gtk_scrolled_window_get_vscrollbar(const_cast<GtkScrolledWindow*>(gobj())));
+  return gobj()->vscrollbar_visible;
 }
 
-HScrollbar* ScrolledWindow::get_hscrollbar()
+Gtk::HScrollbar* ScrolledWindow::get_hscrollbar()
 {
-  return Glib::wrap((GtkHScrollbar*)gtk_scrolled_window_get_hscrollbar(gobj()));
+  return Glib::wrap((GtkHScrollbar*)(gobj()->hscrollbar));
 }
 
-const HScrollbar* ScrolledWindow::get_hscrollbar() const
+const Gtk::HScrollbar* ScrolledWindow::get_hscrollbar() const
 {
-  return Glib::wrap((GtkHScrollbar*)gtk_scrolled_window_get_hscrollbar(const_cast<GtkScrolledWindow*>(gobj())));
+  return Glib::wrap((GtkHScrollbar*)(gobj()->hscrollbar));
 }
 
- bool ScrolledWindow::get_vscrollbar_visible() const
+Gtk::VScrollbar* ScrolledWindow::get_vscrollbar()
 {
-  return gobj()->vscrollbar_visible;
+  return Glib::wrap((GtkVScrollbar*)(gobj()->vscrollbar));
 }
- 
- bool ScrolledWindow::get_hscrollbar_visible() const
+
+const Gtk::VScrollbar* ScrolledWindow::get_vscrollbar() const
 {
-  return gobj()->hscrollbar_visible;
+  return Glib::wrap((GtkVScrollbar*)(gobj()->vscrollbar));
 }
- 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+
 Glib::PropertyProxy<Gtk::Adjustment*> ScrolledWindow::property_hadjustment() 
 {
   return Glib::PropertyProxy<Gtk::Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> ScrolledWindow::property_hadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Adjustment*> ScrolledWindow::property_vadjustment() 
 {
   return Glib::PropertyProxy<Gtk::Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> ScrolledWindow::property_vadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<PolicyType> ScrolledWindow::property_hscrollbar_policy() 
 {
   return Glib::PropertyProxy<PolicyType>(this, "hscrollbar-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<PolicyType> ScrolledWindow::property_hscrollbar_policy() const
 {
   return Glib::PropertyProxy_ReadOnly<PolicyType>(this, "hscrollbar-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<PolicyType> ScrolledWindow::property_vscrollbar_policy() 
 {
   return Glib::PropertyProxy<PolicyType>(this, "vscrollbar-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<PolicyType> ScrolledWindow::property_vscrollbar_policy() const
 {
   return Glib::PropertyProxy_ReadOnly<PolicyType>(this, "vscrollbar-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<CornerType> ScrolledWindow::property_window_placement() 
 {
   return Glib::PropertyProxy<CornerType>(this, "window-placement");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<CornerType> ScrolledWindow::property_window_placement() const
 {
   return Glib::PropertyProxy_ReadOnly<CornerType>(this, "window-placement");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ShadowType> ScrolledWindow::property_shadow_type() 
 {
   return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ShadowType> ScrolledWindow::property_shadow_type() const
 {
   return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/scrolledwindow.h b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.h
index fdd7860ffa..8bb8c66230 100644
--- a/libs/gtkmm2/gtk/gtkmm/scrolledwindow.h
+++ b/libs/gtkmm2/gtk/gtkmm/scrolledwindow.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SCROLLEDWINDOW_H
 #define _GTKMM_SCROLLEDWINDOW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -106,17 +105,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -157,8 +150,6 @@ public:
   
   void set_placement(CornerType window_placement);
   
-  void unset_placement();
-  
   /** Gets the placement of the scrollbars for the scrolled window. See 
    * set_placement().
    * @return The current placement value.
@@ -182,56 +173,24 @@ public:
   virtual void add(Gtk::Widget& widget);
   
 
-  /** Returns the vertical scrollbar of @a scrolled_window .
-   * @return The vertical scrollbar of the scrolled window, or
-   * <tt>0</tt> if it does not have one.
-   * 
-   * @newin2p8.
-   */
-  VScrollbar* get_vscrollbar();
-  
-  /** Returns the vertical scrollbar of @a scrolled_window .
-   * @return The vertical scrollbar of the scrolled window, or
-   * <tt>0</tt> if it does not have one.
-   * 
-   * @newin2p8.
-   */
-  const VScrollbar* get_vscrollbar() const;
+  bool get_vscrollbar_visible() const;
+  bool get_hscrollbar_visible() const;
+  Gtk::HScrollbar* get_hscrollbar();
+  const Gtk::HScrollbar* get_hscrollbar() const;
+  Gtk::VScrollbar* get_vscrollbar();
+  const Gtk::VScrollbar* get_vscrollbar() const;
 
-  
-  /** Returns the horizontal scrollbar of @a scrolled_window .
-   * @return The horizontal scrollbar of the scrolled window, or 
-   * <tt>0</tt> if it does not have one.
-   * 
-   * @newin2p8.
-   */
-  HScrollbar* get_hscrollbar();
-  
-  /** Returns the horizontal scrollbar of @a scrolled_window .
-   * @return The horizontal scrollbar of the scrolled window, or 
-   * <tt>0</tt> if it does not have one.
-   * 
-   * @newin2p8.
-   */
-  const HScrollbar* get_hscrollbar() const;
-
-   bool get_vscrollbar_visible() const;
-    bool get_hscrollbar_visible() const;
- 
   //Keybinding signals:
   
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkAdjustment for the horizontal position.
+  /** The GtkAdjustment for the horizontal position.
    *
    * 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::Adjustment*> property_hadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkAdjustment for the horizontal position.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -239,19 +198,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_hadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkAdjustment for the vertical position.
+  /** The GtkAdjustment for the vertical position.
    *
    * 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::Adjustment*> property_vadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkAdjustment for the vertical position.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -259,19 +214,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_vadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** When the horizontal scrollbar is displayed.
+  /** When the horizontal scrollbar is displayed.
    *
    * 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<PolicyType> property_hscrollbar_policy() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** When the horizontal scrollbar is displayed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -279,19 +230,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<PolicyType> property_hscrollbar_policy() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** When the vertical scrollbar is displayed.
+  /** When the vertical scrollbar is displayed.
    *
    * 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<PolicyType> property_vscrollbar_policy() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** When the vertical scrollbar is displayed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -299,39 +246,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<PolicyType> property_vscrollbar_policy() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Where the contents are located with respect to the scrollbars. This property only takes effect if window-placement-set is TRUE.
+  /** Where the contents are located with respect to the scrollbars.
    *
    * 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<CornerType> property_window_placement() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Where the contents are located with respect to the scrollbars. This property only takes effect if window-placement-set is TRUE.
+/** Where the contents are located with respect to the scrollbars.
    *
    * 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<CornerType> property_window_placement() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Style of bevel around the contents.
+  /** Style of bevel around the contents.
    *
    * 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<ShadowType> property_shadow_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Style of bevel around the contents.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -339,7 +278,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -355,8 +293,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ScrolledWindow* wrap(GtkScrolledWindow* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SCROLLEDWINDOW_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/selectiondata.cc b/libs/gtkmm2/gtk/gtkmm/selectiondata.cc
index f550cedbb9..4770c896fc 100644
--- a/libs/gtkmm2/gtk/gtkmm/selectiondata.cc
+++ b/libs/gtkmm2/gtk/gtkmm/selectiondata.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/selectiondata.h>
 #include <gtkmm/private/selectiondata_p.h>
 
@@ -24,7 +23,6 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <gtkmm/textbuffer.h>
 #include <gdkmm/pixbuf.h>
 #include <glibmm/utility.h> //For ScopedPtr<>.
 #include <gtk/gtkselection.h>
@@ -194,7 +192,7 @@ Glib::RefPtr<Gdk::Pixbuf> SelectionData::get_pixbuf()
 
 Glib::RefPtr<const Gdk::Pixbuf> SelectionData::get_pixbuf() const
 {
-  return const_cast<SelectionData*>(this)->get_pixbuf();
+  return Glib::wrap(gtk_selection_data_get_pixbuf(const_cast<GtkSelectionData*>(gobj())));
 }
 
 bool SelectionData::set_uris(const Glib::StringArrayHandle& uris)
@@ -207,27 +205,27 @@ Glib::StringArrayHandle SelectionData::get_uris() const
   return Glib::StringArrayHandle(gtk_selection_data_get_uris(const_cast<GtkSelectionData*>(gobj())));
 }
 
- const guint8* SelectionData::get_data() const
+const guint8* SelectionData::get_data() const
 {
   return gobj()->data;
 }
- 
- int SelectionData::get_length() const
+
+int SelectionData::get_length() const
 {
   return gobj()->length;
 }
- 
- GdkAtom SelectionData::get_selection() const
+
+GdkAtom SelectionData::get_selection() const
 {
   return gobj()->selection;
 }
- 
- int SelectionData::get_format() const
+
+int SelectionData::get_format() const
 {
   return gobj()->format;
 }
- 
- Glib::RefPtr<Gdk::Display> SelectionData::get_display()
+
+Glib::RefPtr<Gdk::Display> SelectionData::get_display()
 {
   Glib::RefPtr<Gdk::Display> ref_ptr(Glib::wrap(gobj()->display));
 
@@ -246,22 +244,12 @@ Glib::RefPtr<const Gdk::Display> SelectionData::get_display() const
 
   return ref_ptr;
 }
- 
-bool SelectionData::targets_include_uri() const
-{
-  return gtk_selection_data_targets_include_uri(const_cast<GtkSelectionData*>(gobj()));
-}
 
 bool SelectionData::targets_include_text() const
 {
   return gtk_selection_data_targets_include_text(const_cast<GtkSelectionData*>(gobj()));
 }
 
-bool SelectionData::targets_include_rich_text(const Glib::RefPtr<TextBuffer>& buffer) const
-{
-  return gtk_selection_data_targets_include_rich_text(const_cast<GtkSelectionData*>(gobj()), Glib::unwrap(buffer));
-}
-
 bool SelectionData::targets_include_image(bool writable) const
 {
   return gtk_selection_data_targets_include_image(const_cast<GtkSelectionData*>(gobj()), static_cast<int>(writable));
diff --git a/libs/gtkmm2/gtk/gtkmm/selectiondata.h b/libs/gtkmm2/gtk/gtkmm/selectiondata.h
index b3192a24c4..b76bda790a 100644
--- a/libs/gtkmm2/gtk/gtkmm/selectiondata.h
+++ b/libs/gtkmm2/gtk/gtkmm/selectiondata.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SELECTIONDATA_H
 #define _GTKMM_SELECTIONDATA_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -36,10 +35,6 @@ extern "C" { typedef struct _GtkSelectionData GtkSelectionData; }
 namespace Gtk
 {
 
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-class TextBuffer;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
-
 class SelectionData
 {
   public:
@@ -126,7 +121,7 @@ public:
    * @return <tt>true</tt> if the selection was successfully set,
    * otherwise <tt>false</tt>.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
   
@@ -136,7 +131,7 @@ public:
    * newly allocated pixbuf is returned, otherwise <tt>0</tt>.
    * If the result is non-<tt>0</tt> it must be freed with Glib::object_unref().
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<Gdk::Pixbuf> get_pixbuf();
   
@@ -146,7 +141,7 @@ public:
    * newly allocated pixbuf is returned, otherwise <tt>0</tt>.
    * If the result is non-<tt>0</tt> it must be freed with Glib::object_unref().
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::RefPtr<const Gdk::Pixbuf> get_pixbuf() const;
   
@@ -160,7 +155,7 @@ public:
    * @return <tt>true</tt> if the selection was successfully set,
    * otherwise <tt>false</tt>.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool set_uris(const Glib::StringArrayHandle& uris);
   
@@ -170,13 +165,13 @@ public:
    * containing the URIs, otherwise <tt>0</tt>. If the result is 
    * non-<tt>0</tt> it must be freed with Glib::strfreev().
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   Glib::StringArrayHandle get_uris() const;
 
-   const guint8* get_data() const;
-    int get_length() const;
- 
+  const guint8* get_data() const;
+  int get_length() const;
+
   std::string get_data_as_string() const;
 
   std::string get_target() const;
@@ -187,18 +182,16 @@ public:
 
   /** Returns the ID of the selection.
    */
-   GdkAtom get_selection() const;
- 
+  GdkAtom get_selection() const;
+
   /** Returns the type of the data as set by SelectionData::set().
    */
   std::string get_data_type() const; // get_type() already exists
 
-   int get_format() const;
-    Glib::RefPtr<Gdk::Display> get_display();
+  int get_format() const;
+  Glib::RefPtr<Gdk::Display> get_display();
   Glib::RefPtr<const Gdk::Display> get_display() const;
- 
-  
-  bool targets_include_uri() const;
+
   
   /** Given a Gtk::SelectionData object holding a list of targets,
    * determines if any of the targets in @a targets  can be used to
@@ -208,8 +201,6 @@ public:
    */
   bool targets_include_text() const;
   
-  bool targets_include_rich_text(const Glib::RefPtr<TextBuffer>& buffer) const;
-  
   /** Given a Gtk::SelectionData object holding a list of targets,
    * determines if any of the targets in @a targets  can be used to
    * provide a Gdk::Pixbuf.
@@ -218,7 +209,7 @@ public:
    * @return <tt>true</tt> if @a selection_data  holds a list of targets,
    * and a suitable target for images is included, otherwise <tt>false</tt>.
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool targets_include_image(bool writable = true) const;
 
@@ -258,6 +249,5 @@ class Value<Gtk::SelectionData> : public Glib::Value_Boxed<Gtk::SelectionData>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_SELECTIONDATA_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/separator.cc b/libs/gtkmm2/gtk/gtkmm/separator.cc
index 808bd68eb5..8f2b72cba6 100644
--- a/libs/gtkmm2/gtk/gtkmm/separator.cc
+++ b/libs/gtkmm2/gtk/gtkmm/separator.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/separator.h>
 #include <gtkmm/private/separator_p.h>
 
@@ -30,6 +29,7 @@
 #include <gtk/gtkhseparator.h>
 #include <gtk/gtkvseparator.h>
 
+
 namespace
 {
 } // anonymous namespace
@@ -76,19 +76,8 @@ void Separator_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Separator_Class::wrap_new(GObject* o)
 {
@@ -137,13 +126,6 @@ Separator::Separator()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -188,19 +170,8 @@ void VSeparator_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* VSeparator_Class::wrap_new(GObject* o)
 {
@@ -248,13 +219,6 @@ VSeparator::VSeparator()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
@@ -299,19 +263,8 @@ void HSeparator_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* HSeparator_Class::wrap_new(GObject* o)
 {
@@ -359,13 +312,6 @@ HSeparator::HSeparator()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/separator.h b/libs/gtkmm2/gtk/gtkmm/separator.h
index 11475c8514..914fe80308 100644
--- a/libs/gtkmm2/gtk/gtkmm/separator.h
+++ b/libs/gtkmm2/gtk/gtkmm/separator.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SEPARATOR_H
 #define _GTKMM_SEPARATOR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -104,17 +103,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -178,17 +171,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -250,17 +237,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -282,9 +263,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Separator* wrap(GtkSeparator* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::VSeparator
@@ -293,9 +272,7 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::VSeparator* wrap(GtkVSeparator* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 namespace Glib
 {
   /** @relates Gtk::HSeparator
@@ -304,8 +281,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::HSeparator* wrap(GtkHSeparator* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SEPARATOR_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/separatormenuitem.cc b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.cc
index a11e043625..1b06d797c6 100644
--- a/libs/gtkmm2/gtk/gtkmm/separatormenuitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/separatormenuitem.h>
 #include <gtkmm/private/separatormenuitem_p.h>
 
@@ -28,6 +27,7 @@
 
 #include <gtk/gtkseparatormenuitem.h>
 
+
 namespace
 {
 } // anonymous namespace
@@ -74,19 +74,8 @@ void SeparatorMenuItem_Class::class_init_function(void* g_class, void* class_dat
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* SeparatorMenuItem_Class::wrap_new(GObject* o)
 {
@@ -135,13 +124,6 @@ SeparatorMenuItem::SeparatorMenuItem()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/separatormenuitem.h b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.h
index 9d36c664d0..614bb98d78 100644
--- a/libs/gtkmm2/gtk/gtkmm/separatormenuitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/separatormenuitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SEPARATORMENUITEM_H
 #define _GTKMM_SEPARATORMENUITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -91,17 +90,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -123,8 +116,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::SeparatorMenuItem* wrap(GtkSeparatorMenuItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SEPARATORMENUITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/separatortoolitem.cc b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.cc
index 8c03d4e827..4949789d2e 100644
--- a/libs/gtkmm2/gtk/gtkmm/separatortoolitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/separatortoolitem.h>
 #include <gtkmm/private/separatortoolitem_p.h>
 
@@ -80,19 +79,8 @@ void SeparatorToolItem_Class::class_init_function(void* g_class, void* class_dat
   BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
   CppClassParent::class_init_function(klass, class_data);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* SeparatorToolItem_Class::wrap_new(GObject* o)
 {
@@ -141,13 +129,6 @@ SeparatorToolItem::SeparatorToolItem()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/separatortoolitem.h b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.h
index 6e4739594f..00f27cc12e 100644
--- a/libs/gtkmm2/gtk/gtkmm/separatortoolitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/separatortoolitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SEPARATORTOOLITEM_H
 #define _GTKMM_SEPARATORTOOLITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -95,17 +94,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -127,8 +120,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::SeparatorToolItem* wrap(GtkSeparatorToolItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SEPARATORTOOLITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/settings.cc b/libs/gtkmm2/gtk/gtkmm/settings.cc
index 717110285b..7cf9c0738a 100644
--- a/libs/gtkmm2/gtk/gtkmm/settings.cc
+++ b/libs/gtkmm2/gtk/gtkmm/settings.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/settings.h>
 #include <gtkmm/private/settings_p.h>
 
@@ -31,6 +30,13 @@
 namespace Gtk
 {
 
+Glib::RefPtr<Settings> Settings::get_default()
+{
+  Glib::RefPtr<Settings> result = Glib::RefPtr<Settings>( new Settings( gtk_settings_get_default() ) );
+  result->reference(); //gtk_settings_get_default() does not give a reference, so we take one.
+  return result;
+}
+
 
 } //namespace Gtk
 
@@ -83,19 +89,8 @@ void Settings_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Settings_Class::wrap_new(GObject* object)
 {
@@ -138,17 +133,6 @@ GType Settings::get_base_type()
 }
 
 
-Glib::RefPtr<Settings> Settings::get_default()
-{
-
-  Glib::RefPtr<Settings> retvalue = Glib::wrap(gtk_settings_get_default());
-
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-}
-
-
 Glib::RefPtr<Settings> Settings::get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen)
 {
 
@@ -160,334 +144,235 @@ Glib::RefPtr<Settings> Settings::get_for_screen(const Glib::RefPtr<Gdk::Screen>&
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Settings::property_gtk_double_click_time() 
 {
   return Glib::PropertyProxy<int>(this, "gtk-double-click-time");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_double_click_time() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-double-click-time");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Settings::property_gtk_double_click_distance() 
 {
   return Glib::PropertyProxy<int>(this, "gtk-double-click-distance");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_double_click_distance() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-double-click-distance");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Settings::property_gtk_cursor_blink() 
 {
   return Glib::PropertyProxy<bool>(this, "gtk-cursor-blink");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_cursor_blink() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-cursor-blink");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Settings::property_gtk_cursor_blink_time() 
 {
   return Glib::PropertyProxy<int>(this, "gtk-cursor-blink-time");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_cursor_blink_time() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-cursor-blink-time");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Settings::property_gtk_split_cursor() 
 {
   return Glib::PropertyProxy<bool>(this, "gtk-split-cursor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_split_cursor() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-split-cursor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_theme_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-theme-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_theme_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-theme-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_key_theme_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-key-theme-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_key_theme_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-key-theme-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_menu_bar_accel() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-menu-bar-accel");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_menu_bar_accel() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-menu-bar-accel");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Settings::property_gtk_dnd_drag_threshold() 
 {
   return Glib::PropertyProxy<int>(this, "gtk-dnd-drag-threshold");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_dnd_drag_threshold() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-dnd-drag-threshold");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_font_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-font-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_font_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-font-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Settings::property_gtk_xft_antialias() 
 {
   return Glib::PropertyProxy<int>(this, "gtk-xft-antialias");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_xft_antialias() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-xft-antialias");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Settings::property_gtk_xft_hinting() 
 {
   return Glib::PropertyProxy<int>(this, "gtk-xft-hinting");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_xft_hinting() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-xft-hinting");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_xft_hintstyle() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-xft-hintstyle");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_xft_hintstyle() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-xft-hintstyle");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_xft_rgba() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-xft-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_xft_rgba() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-xft-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Settings::property_gtk_xft_dpi() 
 {
   return Glib::PropertyProxy<int>(this, "gtk-xft-dpi");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Settings::property_gtk_xft_dpi() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "gtk-xft-dpi");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ToolbarStyle> Settings::property_gtk_toolbar_style() 
 {
   return Glib::PropertyProxy<ToolbarStyle>(this, "gtk-toolbar-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ToolbarStyle> Settings::property_gtk_toolbar_style() const
 {
   return Glib::PropertyProxy_ReadOnly<ToolbarStyle>(this, "gtk-toolbar-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<IconSize> Settings::property_gtk_toolbar_icon_size() 
 {
   return Glib::PropertyProxy<IconSize>(this, "gtk-toolbar-icon-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<IconSize> Settings::property_gtk_toolbar_icon_size() const
 {
   return Glib::PropertyProxy_ReadOnly<IconSize>(this, "gtk-toolbar-icon-size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Settings::property_gtk_can_change_accels() 
 {
   return Glib::PropertyProxy<bool>(this, "gtk-can-change-accels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_can_change_accels() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-can-change-accels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Settings::property_gtk_entry_select_on_focus() 
 {
   return Glib::PropertyProxy<bool>(this, "gtk-entry-select-on-focus");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_entry_select_on_focus() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-entry-select-on-focus");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_color_palette() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-color-palette");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_color_palette() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-color-palette");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Settings::property_gtk_button_images() 
 {
   return Glib::PropertyProxy<bool>(this, "gtk-button-images");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Settings::property_gtk_button_images() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "gtk-button-images");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_icon_theme_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-icon-theme-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_icon_theme_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-icon-theme-name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Settings::property_gtk_icon_sizes() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "gtk-icon-sizes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Settings::property_gtk_icon_sizes() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "gtk-icon-sizes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/settings.h b/libs/gtkmm2/gtk/gtkmm/settings.h
index 836c3d846b..08cd78d90d 100644
--- a/libs/gtkmm2/gtk/gtkmm/settings.h
+++ b/libs/gtkmm2/gtk/gtkmm/settings.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SETTINGS_H
 #define _GTKMM_SETTINGS_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -93,12 +92,6 @@ protected:
 
 public:
 
-  
-  /** Gets the Gtk::Settings object for the default GDK screen, creating
-   * it if necessary. See get_for_screen().
-   * @return A Gtk::Settings object. If there is no default
-   * screen, then returns <tt>0</tt>.
-   */
   static Glib::RefPtr<Settings> get_default();
 
   
@@ -106,21 +99,18 @@ public:
    * @param screen A Gdk::Screen.
    * @return A Gtk::Settings object.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   static Glib::RefPtr<Settings> get_for_screen(const Glib::RefPtr<Gdk::Screen>& screen);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Maximum time allowed between two clicks for them to be considered a double click (in milliseconds).
+  /** Maximum time allowed between two clicks for them to be considered a double click (in milliseconds).
    *
    * 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_gtk_double_click_time() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Maximum time allowed between two clicks for them to be considered a double click (in milliseconds).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -128,19 +118,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_gtk_double_click_time() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Maximum distance allowed between two clicks for them to be considered a double click (in pixels).
+  /** Maximum distance allowed between two clicks for them to be considered a double click (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<int> property_gtk_double_click_distance() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Maximum distance allowed between two clicks for them to be considered a double click (in pixels).
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -148,19 +134,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_gtk_double_click_distance() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the cursor should blink.
+  /** Whether the cursor should 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<bool> property_gtk_cursor_blink() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the cursor should blink.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -168,19 +150,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_gtk_cursor_blink() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Length of the cursor blink cycle
+  /** Length of the cursor blink cycle
    *
    * 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_gtk_cursor_blink_time() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Length of the cursor blink cycle
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -188,19 +166,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_gtk_cursor_blink_time() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether two cursors should be displayed for mixed left-to-right and right-to-left text.
+  /** Whether two cursors should be displayed for mixed left-to-right and right-to-left 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<bool> property_gtk_split_cursor() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether two cursors should be displayed for mixed left-to-right and right-to-left text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -208,19 +182,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_gtk_split_cursor() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of theme RC file to load.
+  /** Name of theme RC file to load.
    *
    * 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_gtk_theme_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Name of theme RC file to load.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -228,19 +198,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_theme_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of key theme RC file to load.
+  /** Name of key theme RC file to load.
    *
    * 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_gtk_key_theme_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Name of key theme RC file to load.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -248,19 +214,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_key_theme_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Keybinding to activate the menu bar.
+  /** Keybinding to activate the menu bar.
    *
    * 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_gtk_menu_bar_accel() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Keybinding to activate the menu bar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -268,19 +230,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_menu_bar_accel() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels the cursor can move before dragging.
+  /** Number of pixels the cursor can move before dragging.
    *
    * 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_gtk_dnd_drag_threshold() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Number of pixels the cursor can move before dragging.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -288,19 +246,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_gtk_dnd_drag_threshold() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of default font to use.
+  /** Name of default font to use.
    *
    * 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_gtk_font_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Name of default font to use.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -308,19 +262,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_font_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to antialias Xft fonts; 0=no
+  /** Whether to antialias Xft fonts; 0=no
    *
    * 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_gtk_xft_antialias() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to antialias Xft fonts; 0=no
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -328,19 +278,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_gtk_xft_antialias() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to hint Xft fonts; 0=no
+  /** Whether to hint Xft fonts; 0=no
    *
    * 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_gtk_xft_hinting() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to hint Xft fonts; 0=no
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -348,39 +294,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_gtk_xft_hinting() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** What degree of hinting to use; hintnone
+  /** What degree of hinting to use; none
    *
    * 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_gtk_xft_hintstyle() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** What degree of hinting to use; hintnone
+/** What degree of hinting to use; none
    *
    * 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_gtk_xft_hintstyle() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Type of subpixel antialiasing; none
+  /** Type of subpixel antialiasing; none
    *
    * 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_gtk_xft_rgba() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Type of subpixel antialiasing; none
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -388,19 +326,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_xft_rgba() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Resolution for Xft
+  /** Resolution for Xft
    *
    * 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_gtk_xft_dpi() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Resolution for Xft
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -408,21 +342,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_gtk_xft_dpi() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   // from GtkToolbar
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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<ToolbarStyle> property_gtk_toolbar_style() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -430,19 +360,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ToolbarStyle> property_gtk_toolbar_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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<IconSize> property_gtk_toolbar_icon_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -450,21 +376,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<IconSize> property_gtk_toolbar_icon_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   // from GtkMenu
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_gtk_can_change_accels() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -472,21 +394,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_gtk_can_change_accels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   // from GtkEntry
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_gtk_entry_select_on_focus() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -494,21 +412,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_gtk_entry_select_on_focus() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   // from GtkColorSelection
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_gtk_color_palette() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -516,21 +430,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_color_palette() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   // from GtkButton
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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_gtk_button_images() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -538,21 +448,17 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_gtk_button_images() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   // from GtkIconTheme
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of icon theme to use.
+  /** Name of icon theme to use.
    *
    * 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_gtk_icon_theme_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Name of icon theme to use.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -560,44 +466,33 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_gtk_icon_theme_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** List of icon sizes: gtk-menu=16
+  /** List of icon sizes gtk-menu=16
    *
    * 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_gtk_icon_sizes() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** List of icon sizes: gtk-menu=16
+/** List of icon sizes gtk-menu=16
    *
    * 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_gtk_icon_sizes() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/sizegroup.cc b/libs/gtkmm2/gtk/gtkmm/sizegroup.cc
index 94ee095ebb..40c350749f 100644
--- a/libs/gtkmm2/gtk/gtkmm/sizegroup.cc
+++ b/libs/gtkmm2/gtk/gtkmm/sizegroup.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/sizegroup.h>
 #include <gtkmm/private/sizegroup_p.h>
 
@@ -95,19 +94,8 @@ void SizeGroup_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* SizeGroup_Class::wrap_new(GObject* object)
 {
@@ -156,7 +144,7 @@ Glib::RefPtr<SizeGroup> SizeGroup::create(SizeGroupMode mode)
 }
 void SizeGroup::set_mode(SizeGroupMode mode)
 {
-gtk_size_group_set_mode(gobj(), ((GtkSizeGroupMode)(mode))); 
+  gtk_size_group_set_mode(gobj(), ((GtkSizeGroupMode)(mode)));
 }
 
 SizeGroupMode SizeGroup::get_mode() const
@@ -164,71 +152,26 @@ SizeGroupMode SizeGroup::get_mode() const
   return ((SizeGroupMode)(gtk_size_group_get_mode(const_cast<GtkSizeGroup*>(gobj()))));
 }
 
-void SizeGroup::set_ignore_hidden(bool ignore_hidden)
-{
-gtk_size_group_set_ignore_hidden(gobj(), static_cast<int>(ignore_hidden)); 
-}
-
-bool SizeGroup::get_ignore_hidden() const
-{
-  return gtk_size_group_get_ignore_hidden(const_cast<GtkSizeGroup*>(gobj()));
-}
-
 void SizeGroup::add_widget(Widget& widget)
 {
-gtk_size_group_add_widget(gobj(), (widget).gobj()); 
+  gtk_size_group_add_widget(gobj(), (widget).gobj());
 }
 
 void SizeGroup::remove_widget(Widget& widget)
 {
-gtk_size_group_remove_widget(gobj(), (widget).gobj()); 
+  gtk_size_group_remove_widget(gobj(), (widget).gobj());
 }
 
-Glib::SListHandle<Widget*> SizeGroup::get_widgets()
-{
-  return Glib::SListHandle<Widget*>(gtk_size_group_get_widgets(gobj()), Glib::OWNERSHIP_SHALLOW);
-}
 
-Glib::SListHandle<const Widget*> SizeGroup::get_widgets() const
-{
-  return Glib::SListHandle<const Widget*>(gtk_size_group_get_widgets(const_cast<GtkSizeGroup*>(gobj())), Glib::OWNERSHIP_SHALLOW);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<SizeGroupMode> SizeGroup::property_mode() 
 {
   return Glib::PropertyProxy<SizeGroupMode>(this, "mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<SizeGroupMode> SizeGroup::property_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<SizeGroupMode>(this, "mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> SizeGroup::property_ignore_hidden() 
-{
-  return Glib::PropertyProxy<bool>(this, "ignore-hidden");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> SizeGroup::property_ignore_hidden() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "ignore-hidden");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/sizegroup.h b/libs/gtkmm2/gtk/gtkmm/sizegroup.h
index 03d4723f12..d3fb6991eb 100644
--- a/libs/gtkmm2/gtk/gtkmm/sizegroup.h
+++ b/libs/gtkmm2/gtk/gtkmm/sizegroup.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SIZEGROUP_H
 #define _GTKMM_SIZEGROUP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -78,24 +77,6 @@ namespace Gtk
 {
 
 
-/** Gtk::SizeGroup provides a mechanism for grouping a number of widgets together so they all request the same amount of space. 
- * This is typically useful when you want a column of widgets to have the same size, but you can't use a Gtk::Table widget.
- * 
- * In detail, the size requested for each widget in a Gtk::SizeGroup is the maximum of the sizes that would have been 
- * requested for each widget in the size group if they were not in the size group. The mode of the size group (see 
- * set_mode()) determines whether this applies to the horizontal size, the vertical size, or both sizes.
- *
- * Note that size groups only affect the amount of space requested, not the size that the widgets finally receive. If 
- * you want the widgets in a GtkSizeGroup to actually be the same size, you need to pack them in such a way that they 
- * get the size they request and not more. For example, if you are packing your widgets into a table, you would not 
- * include the Gtk::FILL flag.
- * 
- * Widgets can be part of multiple size groups; GTK+ will compute the horizontal size of a widget from the horizontal 
- * requisition of all widgets that can be reached from the widget by a chain of size groups of type 
- * Gtk::SIZE_GROUP_HORIZONTAL or Gtk::SIZE_GROUP_BOTH, and the vertical size from the vertical requisition of all widgets  
- * that can be reached from the widget by a chain of size groups of type Gtk::SIZE_GROUP_VERTICAL or Gtk::SIZE_GROUP_BOTH.
- */
-
 class SizeGroup : public Glib::Object
 {
   
@@ -163,24 +144,6 @@ public:
    * @return The current mode of the size group.
    */
   SizeGroupMode get_mode() const;
-
-  
-  /** Sets whether invisible widgets should be ignored when
-   * calculating the size.
-   * 
-   * @newin2p8
-   * @param ignore_hidden Whether hidden widgets should be ignored
-   * when calculating the size.
-   */
-  void set_ignore_hidden(bool ignore_hidden = true);
-  
-  /** Returns if invisible widgets are ignored when calculating the size.
-   * @return <tt>true</tt> if invisible widgets are ignored.
-   * 
-   * @newin2p8.
-   */
-  bool get_ignore_hidden() const;
-
   
   /** Adds a widget to a Gtk::SizeGroup. In the future, the requisition
    * of the widget will be determined as the maximum of its requisition
@@ -196,67 +159,32 @@ public:
    */
   void remove_widget(Widget& widget);
 
-  
-  Glib::SListHandle<Widget*> get_widgets();
-  
-  Glib::SListHandle<const Widget*> get_widgets() const;
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The directions in which the size group affects the requested sizes of its component widgets.
+  /** The directions in which the size group effects the requested sizes of its component widgets.
    *
    * 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<SizeGroupMode> property_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The directions in which the size group affects the requested sizes of its component widgets.
+/** The directions in which the size group effects the requested sizes of its component widgets.
    *
    * 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<SizeGroupMode> property_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
-   *
-   * 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_ignore_hidden() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
-   *
-   * 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_ignore_hidden() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/socket.cc b/libs/gtkmm2/gtk/gtkmm/socket.cc
index b6566cf7f6..050d5a2dcd 100644
--- a/libs/gtkmm2/gtk/gtkmm/socket.cc
+++ b/libs/gtkmm2/gtk/gtkmm/socket.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/socket.h>
 #include <gtkmm/private/socket_p.h>
 
@@ -30,8 +29,7 @@
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Socket_signal_plug_added_info =
+const Glib::SignalProxyInfo Socket_signal_plug_added_info =
 {
   "plug_added",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -39,7 +37,7 @@ static const Glib::SignalProxyInfo Socket_signal_plug_added_info =
 };
 
 
-static gboolean Socket_signal_plug_removed_callback(GtkSocket* self, void* data)
+gboolean Socket_signal_plug_removed_callback(GtkSocket* self, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool > SlotType;
@@ -47,26 +45,22 @@ static gboolean Socket_signal_plug_removed_callback(GtkSocket* self, void* data)
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Socket_signal_plug_removed_notify_callback(GtkSocket* self,  void* data)
+gboolean Socket_signal_plug_removed_notify_callback(GtkSocket* self,  void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void > SlotType;
@@ -74,33 +68,28 @@ static gboolean Socket_signal_plug_removed_notify_callback(GtkSocket* self,  voi
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Socket_signal_plug_removed_info =
+const Glib::SignalProxyInfo Socket_signal_plug_removed_info =
 {
   "plug_removed",
   (GCallback) &Socket_signal_plug_removed_callback,
   (GCallback) &Socket_signal_plug_removed_notify_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -145,19 +134,11 @@ void Socket_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->plug_added = &plug_added_callback;
   klass->plug_removed = &plug_removed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Socket_Class::plug_added_callback(GtkSocket* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -170,19 +151,15 @@ void Socket_Class::plug_added_callback(GtkSocket* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_plug_added();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -195,6 +172,7 @@ void Socket_Class::plug_added_callback(GtkSocket* self)
       (*base->plug_added)(self);
   }
 }
+
 gboolean Socket_Class::plug_removed_callback(GtkSocket* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -207,19 +185,15 @@ gboolean Socket_Class::plug_removed_callback(GtkSocket* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_plug_removed());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -235,7 +209,6 @@ gboolean Socket_Class::plug_removed_callback(GtkSocket* self)
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Socket_Class::wrap_new(GObject* o)
@@ -286,7 +259,7 @@ Socket::Socket()
 
 void Socket::add_id(Gdk::NativeWindow window_id)
 {
-gtk_socket_add_id(gobj(), (GdkNativeWindow)(window_id)); 
+  gtk_socket_add_id(gobj(), (GdkNativeWindow)(window_id));
 }
 
 Gdk::NativeWindow Socket::get_id() const
@@ -300,14 +273,12 @@ Glib::SignalProxy0< void > Socket::signal_plug_added()
   return Glib::SignalProxy0< void >(this, &Socket_signal_plug_added_info);
 }
 
-
 Glib::SignalProxy0< bool > Socket::signal_plug_removed()
 {
   return Glib::SignalProxy0< bool >(this, &Socket_signal_plug_removed_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Socket::on_plug_added()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -317,6 +288,7 @@ void Gtk::Socket::on_plug_added()
   if(base && base->plug_added)
     (*base->plug_added)(gobj());
 }
+
 bool Gtk::Socket::on_plug_removed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -329,10 +301,6 @@ bool Gtk::Socket::on_plug_removed()
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/socket.h b/libs/gtkmm2/gtk/gtkmm/socket.h
index 259466f16d..3b6d58aa96 100644
--- a/libs/gtkmm2/gtk/gtkmm/socket.h
+++ b/libs/gtkmm2/gtk/gtkmm/socket.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SOCKET_H
 #define _GTKMM_SOCKET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -130,19 +129,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_plug_added();
   virtual bool on_plug_removed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -183,19 +176,9 @@ public:
   Gdk::NativeWindow get_id() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %plug_added()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_plug_added();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %plug_removed()</tt>
-   */
-
   Glib::SignalProxy0< bool > signal_plug_removed();
 
 
@@ -212,8 +195,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Socket* wrap(GtkSocket* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SOCKET_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/spinbutton.cc b/libs/gtkmm2/gtk/gtkmm/spinbutton.cc
index 766c34d2df..d82f8baab4 100644
--- a/libs/gtkmm2/gtk/gtkmm/spinbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/spinbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/spinbutton.h>
 #include <gtkmm/private/spinbutton_p.h>
 
@@ -48,8 +47,7 @@ void SpinButton::unset_adjustment()
 namespace
 {
 
-
-static gint SpinButton_signal_input_callback(GtkSpinButton* self, double* p0,void* data)
+gint SpinButton_signal_input_callback(GtkSpinButton* self, gdouble* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< int,double* > SlotType;
@@ -57,26 +55,23 @@ static gint SpinButton_signal_input_callback(GtkSpinButton* self, double* p0,voi
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        return (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
+        return (*static_cast<SlotType*>(slot))(p0
+);
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gint RType;
   return RType();
 }
 
-static gint SpinButton_signal_input_notify_callback(GtkSpinButton* self, double* p0, void* data)
+gint SpinButton_signal_input_notify_callback(GtkSpinButton* self, gdouble* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,double* > SlotType;
@@ -84,26 +79,23 @@ static gint SpinButton_signal_input_notify_callback(GtkSpinButton* self, double*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
+        (*static_cast<SlotType*>(slot))(p0
+);
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gint RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo SpinButton_signal_input_info =
+const Glib::SignalProxyInfo SpinButton_signal_input_info =
 {
   "input",
   (GCallback) &SpinButton_signal_input_callback,
@@ -111,7 +103,7 @@ static const Glib::SignalProxyInfo SpinButton_signal_input_info =
 };
 
 
-static gboolean SpinButton_signal_output_callback(GtkSpinButton* self, void* data)
+gboolean SpinButton_signal_output_callback(GtkSpinButton* self, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool > SlotType;
@@ -119,26 +111,22 @@ static gboolean SpinButton_signal_output_callback(GtkSpinButton* self, void* dat
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean SpinButton_signal_output_notify_callback(GtkSpinButton* self,  void* data)
+gboolean SpinButton_signal_output_notify_callback(GtkSpinButton* self,  void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void > SlotType;
@@ -146,26 +134,22 @@ static gboolean SpinButton_signal_output_notify_callback(GtkSpinButton* self,  v
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo SpinButton_signal_output_info =
+const Glib::SignalProxyInfo SpinButton_signal_output_info =
 {
   "output",
   (GCallback) &SpinButton_signal_output_callback,
@@ -173,46 +157,13 @@ static const Glib::SignalProxyInfo SpinButton_signal_output_info =
 };
 
 
-static void SpinButton_signal_wrapped_callback(GtkSpinButton* self, void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< bool > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-}
-
-static const Glib::SignalProxyInfo SpinButton_signal_wrapped_info =
-{
-  "wrapped",
-  (GCallback) &SpinButton_signal_wrapped_callback,
-  (GCallback) &SpinButton_signal_wrapped_callback
-};
-
-
-static const Glib::SignalProxyInfo SpinButton_signal_value_changed_info =
+const Glib::SignalProxyInfo SpinButton_signal_value_changed_info =
 {
   "value_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -270,21 +221,13 @@ void SpinButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->input = &input_callback;
   klass->output = &output_callback;
   klass->value_changed = &value_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-gint SpinButton_Class::input_callback(GtkSpinButton* self, double* p0)
+gint SpinButton_Class::input_callback(GtkSpinButton* self, gdouble* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
@@ -296,19 +239,16 @@ gint SpinButton_Class::input_callback(GtkSpinButton* self, double* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
-      return obj->on_input(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
+      return obj->on_input(p0
+);
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -324,6 +264,7 @@ gint SpinButton_Class::input_callback(GtkSpinButton* self, double* p0)
   typedef gint RType;
   return RType();
 }
+
 gboolean SpinButton_Class::output_callback(GtkSpinButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -336,19 +277,15 @@ gboolean SpinButton_Class::output_callback(GtkSpinButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_output());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -364,6 +301,7 @@ gboolean SpinButton_Class::output_callback(GtkSpinButton* self)
   typedef gboolean RType;
   return RType();
 }
+
 void SpinButton_Class::value_changed_callback(GtkSpinButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -376,19 +314,15 @@ void SpinButton_Class::value_changed_callback(GtkSpinButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_value_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -401,7 +335,6 @@ void SpinButton_Class::value_changed_callback(GtkSpinButton* self)
       (*base->value_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* SpinButton_Class::wrap_new(GObject* o)
@@ -452,12 +385,12 @@ SpinButton::SpinButton(Adjustment& adjustment, double climb_rate, guint digits)
 
 void SpinButton::configure(Adjustment& adjustment, double climb_rate, guint digits)
 {
-gtk_spin_button_configure(gobj(), (adjustment).gobj(), climb_rate, digits); 
+  gtk_spin_button_configure(gobj(), (adjustment).gobj(), climb_rate, digits);
 }
 
 void SpinButton::set_adjustment(Adjustment& adjustment)
 {
-gtk_spin_button_set_adjustment(gobj(), (adjustment).gobj()); 
+  gtk_spin_button_set_adjustment(gobj(), (adjustment).gobj());
 }
 
 Gtk::Adjustment* SpinButton::get_adjustment()
@@ -467,12 +400,12 @@ Gtk::Adjustment* SpinButton::get_adjustment()
 
 const Gtk::Adjustment* SpinButton::get_adjustment() const
 {
-  return const_cast<SpinButton*>(this)->get_adjustment();
+  return Glib::wrap(gtk_spin_button_get_adjustment(const_cast<GtkSpinButton*>(gobj())));
 }
 
 void SpinButton::set_digits(guint digits)
 {
-gtk_spin_button_set_digits(gobj(), digits); 
+  gtk_spin_button_set_digits(gobj(), digits);
 }
 
 guint SpinButton::get_digits() const
@@ -482,22 +415,22 @@ guint SpinButton::get_digits() const
 
 void SpinButton::set_increments(double step, double page)
 {
-gtk_spin_button_set_increments(gobj(), step, page); 
+  gtk_spin_button_set_increments(gobj(), step, page);
 }
 
 void SpinButton::get_increments(double& step, double& page) const
 {
-gtk_spin_button_get_increments(const_cast<GtkSpinButton*>(gobj()), &(step), &(page)); 
+  gtk_spin_button_get_increments(const_cast<GtkSpinButton*>(gobj()), &(step), &(page));
 }
 
 void SpinButton::set_range(double min, double max)
 {
-gtk_spin_button_set_range(gobj(), min, max); 
+  gtk_spin_button_set_range(gobj(), min, max);
 }
 
 void SpinButton::get_range(double& min, double& max) const
 {
-gtk_spin_button_get_range(const_cast<GtkSpinButton*>(gobj()), &(min), &(max)); 
+  gtk_spin_button_get_range(const_cast<GtkSpinButton*>(gobj()), &(min), &(max));
 }
 
 double SpinButton::get_value() const
@@ -512,12 +445,12 @@ int SpinButton::get_value_as_int() const
 
 void SpinButton::set_value(double value)
 {
-gtk_spin_button_set_value(gobj(), value); 
+  gtk_spin_button_set_value(gobj(), value);
 }
 
 void SpinButton::set_update_policy(SpinButtonUpdatePolicy policy)
 {
-gtk_spin_button_set_update_policy(gobj(), ((GtkSpinButtonUpdatePolicy)(policy))); 
+  gtk_spin_button_set_update_policy(gobj(), ((GtkSpinButtonUpdatePolicy)(policy)));
 }
 
 SpinButtonUpdatePolicy SpinButton::get_update_policy() const
@@ -527,7 +460,7 @@ SpinButtonUpdatePolicy SpinButton::get_update_policy() const
 
 void SpinButton::set_numeric(bool numeric)
 {
-gtk_spin_button_set_numeric(gobj(), static_cast<int>(numeric)); 
+  gtk_spin_button_set_numeric(gobj(), static_cast<int>(numeric));
 }
 
 bool SpinButton::get_numeric() const
@@ -537,12 +470,12 @@ bool SpinButton::get_numeric() const
 
 void SpinButton::spin(SpinType direction, double increment)
 {
-gtk_spin_button_spin(gobj(), ((GtkSpinType)(direction)), increment); 
+  gtk_spin_button_spin(gobj(), ((GtkSpinType)(direction)), increment);
 }
 
 void SpinButton::set_wrap(bool wrap)
 {
-gtk_spin_button_set_wrap(gobj(), static_cast<int>(wrap)); 
+  gtk_spin_button_set_wrap(gobj(), static_cast<int>(wrap));
 }
 
 bool SpinButton::get_wrap() const
@@ -552,7 +485,7 @@ bool SpinButton::get_wrap() const
 
 void SpinButton::set_snap_to_ticks(bool snap_to_ticks)
 {
-gtk_spin_button_set_snap_to_ticks(gobj(), static_cast<int>(snap_to_ticks)); 
+  gtk_spin_button_set_snap_to_ticks(gobj(), static_cast<int>(snap_to_ticks));
 }
 
 bool SpinButton::get_snap_to_ticks() const
@@ -562,7 +495,7 @@ bool SpinButton::get_snap_to_ticks() const
 
 void SpinButton::update()
 {
-gtk_spin_button_update(gobj()); 
+  gtk_spin_button_update(gobj());
 }
 
 
@@ -571,139 +504,98 @@ Glib::SignalProxy1< int,double* > SpinButton::signal_input()
   return Glib::SignalProxy1< int,double* >(this, &SpinButton_signal_input_info);
 }
 
-
 Glib::SignalProxy0< bool > SpinButton::signal_output()
 {
   return Glib::SignalProxy0< bool >(this, &SpinButton_signal_output_info);
 }
 
-
-Glib::SignalProxy0< bool > SpinButton::signal_wrapped()
-{
-  return Glib::SignalProxy0< bool >(this, &SpinButton_signal_wrapped_info);
-}
-
-
 Glib::SignalProxy0< void > SpinButton::signal_value_changed()
 {
   return Glib::SignalProxy0< void >(this, &SpinButton_signal_value_changed_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Adjustment*> SpinButton::property_adjustment() 
 {
   return Glib::PropertyProxy<Gtk::Adjustment*>(this, "adjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> SpinButton::property_adjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "adjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> SpinButton::property_climb_rate() 
 {
   return Glib::PropertyProxy<double>(this, "climb-rate");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> SpinButton::property_climb_rate() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "climb-rate");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> SpinButton::property_digits() 
 {
   return Glib::PropertyProxy<guint>(this, "digits");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> SpinButton::property_digits() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "digits");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> SpinButton::property_snap_to_ticks() 
 {
   return Glib::PropertyProxy<bool>(this, "snap-to-ticks");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> SpinButton::property_snap_to_ticks() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "snap-to-ticks");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> SpinButton::property_numeric() 
 {
   return Glib::PropertyProxy<bool>(this, "numeric");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> SpinButton::property_numeric() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "numeric");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> SpinButton::property_wrap() 
 {
   return Glib::PropertyProxy<bool>(this, "wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> SpinButton::property_wrap() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<SpinButtonUpdatePolicy> SpinButton::property_update_policy() 
 {
   return Glib::PropertyProxy<SpinButtonUpdatePolicy>(this, "update-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<SpinButtonUpdatePolicy> SpinButton::property_update_policy() const
 {
   return Glib::PropertyProxy_ReadOnly<SpinButtonUpdatePolicy>(this, "update-policy");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> SpinButton::property_value() 
 {
   return Glib::PropertyProxy<double>(this, "value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> SpinButton::property_value() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "value");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 int Gtk::SpinButton::on_input(double* new_value)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -716,6 +608,7 @@ int Gtk::SpinButton::on_input(double* new_value)
   typedef int RType;
   return RType();
 }
+
 bool Gtk::SpinButton::on_output()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -728,6 +621,7 @@ bool Gtk::SpinButton::on_output()
   typedef bool RType;
   return RType();
 }
+
 void Gtk::SpinButton::on_value_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -737,10 +631,6 @@ void Gtk::SpinButton::on_value_changed()
   if(base && base->value_changed)
     (*base->value_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/spinbutton.h b/libs/gtkmm2/gtk/gtkmm/spinbutton.h
index 7544668d64..d679054425 100644
--- a/libs/gtkmm2/gtk/gtkmm/spinbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/spinbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_SPINBUTTON_H
 #define _GTKMM_SPINBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -163,20 +162,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual int on_input(double* new_value);
   virtual bool on_output();
   virtual void on_value_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -342,10 +335,6 @@ public:
    * @li <tt>Gtk::INPUT_ERROR</tt>: Conversion failed, don't call default handler.
    */
   
-/**
-   * @par Prototype:
-   * <tt>int %input(double* new_value)</tt>
-   */
 
   Glib::SignalProxy1< int,double* > signal_input();
 
@@ -357,44 +346,24 @@ public:
    * @li <tt>true</tt>: Conversion successful, don't call default handler.
    */
   
-/**
-   * @par Prototype:
-   * <tt>bool %output()</tt>
-   */
 
   Glib::SignalProxy0< bool > signal_output();
 
 
-/**
-   * @par Prototype:
-   * <tt>bool %wrapped()</tt>
-   */
-
-  Glib::SignalProxy0< bool > signal_wrapped();
-
-
-/**
-   * @par Prototype:
-   * <tt>void %value_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_value_changed();
 
 
   //Keybinding signals:
   
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The adjustment that holds the value of the spinbutton.
+  /** The adjustment that holds the value of the spinbutton.
    *
    * 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::Adjustment*> property_adjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The adjustment that holds the value of the spinbutton.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -402,19 +371,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_adjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The acceleration rate when you hold down a button.
+  /** The acceleration rate when you hold down a button.
    *
    * 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_climb_rate() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The acceleration rate when you hold down a button.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -422,19 +387,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_climb_rate() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of decimal places to display.
+  /** The number of decimal places to display.
    *
    * 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_digits() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The number of decimal places to display.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -442,19 +403,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_digits() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether erroneous values are automatically changed to a spin button's nearest step increment.
+  /** Whether erroneous values are automatically changed to a spin button's nearest step increment.
    *
    * 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_snap_to_ticks() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether erroneous values are automatically changed to a spin button's nearest step increment.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -462,19 +419,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_snap_to_ticks() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether non-numeric characters should be ignored.
+  /** Whether non-numeric characters should be ignored.
    *
    * 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_numeric() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether non-numeric characters should be ignored.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -482,19 +435,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_numeric() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether a spin button should wrap upon reaching its limits.
+  /** Whether a spin button should wrap upon reaching its limits.
    *
    * 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_wrap() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether a spin button should wrap upon reaching its limits.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -502,19 +451,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_wrap() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the spin button should update always
+  /** Whether the spin button should update always
    *
    * 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<SpinButtonUpdatePolicy> property_update_policy() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the spin button should update always
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -522,19 +467,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<SpinButtonUpdatePolicy> property_update_policy() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Reads the current value
+  /** Reads the current value
    *
    * 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_value() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Reads the current value
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -542,7 +483,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_value() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -558,8 +498,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::SpinButton* wrap(GtkSpinButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_SPINBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/statusbar.cc b/libs/gtkmm2/gtk/gtkmm/statusbar.cc
index b53aec1645..1e6e28071e 100644
--- a/libs/gtkmm2/gtk/gtkmm/statusbar.cc
+++ b/libs/gtkmm2/gtk/gtkmm/statusbar.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/statusbar.h>
 #include <gtkmm/private/statusbar_p.h>
 
@@ -47,8 +46,7 @@ void Statusbar::remove_message(guint message_id, guint context_id /* = 0 */)
 namespace
 {
 
-
-static void Statusbar_signal_text_pushed_callback(GtkStatusbar* self, guint p0,const gchar* p1,void* data)
+void Statusbar_signal_text_pushed_callback(GtkStatusbar* self, guint p0,const gchar* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,guint,const Glib::ustring& > SlotType;
@@ -56,24 +54,20 @@ static void Statusbar_signal_text_pushed_callback(GtkStatusbar* self, guint p0,c
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Statusbar_signal_text_pushed_info =
+const Glib::SignalProxyInfo Statusbar_signal_text_pushed_info =
 {
   "text_pushed",
   (GCallback) &Statusbar_signal_text_pushed_callback,
@@ -81,7 +75,7 @@ static const Glib::SignalProxyInfo Statusbar_signal_text_pushed_info =
 };
 
 
-static void Statusbar_signal_text_popped_callback(GtkStatusbar* self, guint p0,const gchar* p1,void* data)
+void Statusbar_signal_text_popped_callback(GtkStatusbar* self, guint p0,const gchar* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,guint,const Glib::ustring& > SlotType;
@@ -89,31 +83,26 @@ static void Statusbar_signal_text_popped_callback(GtkStatusbar* self, guint p0,c
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Statusbar_signal_text_popped_info =
+const Glib::SignalProxyInfo Statusbar_signal_text_popped_info =
 {
   "text_popped",
   (GCallback) &Statusbar_signal_text_popped_callback,
   (GCallback) &Statusbar_signal_text_popped_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -158,19 +147,11 @@ void Statusbar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->text_pushed = &text_pushed_callback;
   klass->text_popped = &text_popped_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Statusbar_Class::text_pushed_callback(GtkStatusbar* self, guint p0, const gchar* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -183,20 +164,16 @@ void Statusbar_Class::text_pushed_callback(GtkStatusbar* self, guint p0, const g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_text_pushed(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -209,6 +186,7 @@ void Statusbar_Class::text_pushed_callback(GtkStatusbar* self, guint p0, const g
       (*base->text_pushed)(self, p0, p1);
   }
 }
+
 void Statusbar_Class::text_popped_callback(GtkStatusbar* self, guint p0, const gchar* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -221,20 +199,16 @@ void Statusbar_Class::text_popped_callback(GtkStatusbar* self, guint p0, const g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_text_popped(p0, Glib::convert_const_gchar_ptr_to_ustring(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -247,7 +221,6 @@ void Statusbar_Class::text_popped_callback(GtkStatusbar* self, guint p0, const g
       (*base->text_popped)(self, p0, p1);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Statusbar_Class::wrap_new(GObject* o)
@@ -303,12 +276,12 @@ guint Statusbar::get_context_id(const Glib::ustring& context_description)
 
 void Statusbar::pop(guint context_id)
 {
-gtk_statusbar_pop(gobj(), context_id); 
+  gtk_statusbar_pop(gobj(), context_id);
 }
 
 void Statusbar::set_has_resize_grip(bool setting)
 {
-gtk_statusbar_set_has_resize_grip(gobj(), static_cast<int>(setting)); 
+  gtk_statusbar_set_has_resize_grip(gobj(), static_cast<int>(setting));
 }
 
 bool Statusbar::get_has_resize_grip() const
@@ -322,29 +295,23 @@ Glib::SignalProxy2< void,guint,const Glib::ustring& > Statusbar::signal_text_pus
   return Glib::SignalProxy2< void,guint,const Glib::ustring& >(this, &Statusbar_signal_text_pushed_info);
 }
 
-
 Glib::SignalProxy2< void,guint,const Glib::ustring& > Statusbar::signal_text_popped()
 {
   return Glib::SignalProxy2< void,guint,const Glib::ustring& >(this, &Statusbar_signal_text_popped_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Statusbar::property_has_resize_grip() 
 {
   return Glib::PropertyProxy<bool>(this, "has-resize-grip");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Statusbar::property_has_resize_grip() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-resize-grip");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Statusbar::on_text_pushed(guint context_id, const Glib::ustring& text)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -354,6 +321,7 @@ void Gtk::Statusbar::on_text_pushed(guint context_id, const Glib::ustring& text)
   if(base && base->text_pushed)
     (*base->text_pushed)(gobj(),context_id,text.c_str());
 }
+
 void Gtk::Statusbar::on_text_popped(guint context_id, const Glib::ustring& text)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -363,10 +331,6 @@ void Gtk::Statusbar::on_text_popped(guint context_id, const Glib::ustring& text)
   if(base && base->text_popped)
     (*base->text_popped)(gobj(),context_id,text.c_str());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/statusbar.h b/libs/gtkmm2/gtk/gtkmm/statusbar.h
index a1eff80471..6bade10932 100644
--- a/libs/gtkmm2/gtk/gtkmm/statusbar.h
+++ b/libs/gtkmm2/gtk/gtkmm/statusbar.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_STATUSBAR_H
 #define _GTKMM_STATUSBAR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,19 +95,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_text_pushed(guint context_id, const Glib::ustring& text);
   virtual void on_text_popped(guint context_id, const Glib::ustring& text);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -129,33 +122,20 @@ public:
   bool get_has_resize_grip() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %text_pushed(guint context_id, const Glib::ustring& text)</tt>
-   */
-
   Glib::SignalProxy2< void,guint,const Glib::ustring& > signal_text_pushed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %text_popped(guint context_id, const Glib::ustring& text)</tt>
-   */
-
   Glib::SignalProxy2< void,guint,const Glib::ustring& > signal_text_popped();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the statusbar has a grip for resizing the toplevel.
+  /** Whether the statusbar has a grip for resizing the toplevel.
    *
    * 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_has_resize_grip() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the statusbar has a grip for resizing the toplevel.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -163,7 +143,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_resize_grip() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -179,8 +158,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Statusbar* wrap(GtkStatusbar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_STATUSBAR_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/statusicon.cc b/libs/gtkmm2/gtk/gtkmm/statusicon.cc
deleted file mode 100644
index a02cf92ed8..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/statusicon.cc
+++ /dev/null
@@ -1,495 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <gtkmm/statusicon.h>
-#include <gtkmm/private/statusicon_p.h>
-
-// -*- c++ -*-
-/* $Id: statusicon.ccg,v 1.4 2006/06/21 20:34:39 murrayc Exp $ */
-
-/* Copyright 2005 The gtkmm 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 <gtk/gtkstatusicon.h>
-
-
-namespace Gtk
-{
-
-Glib::RefPtr<StatusIcon> StatusIcon::create_from_file(const std::string& filename)
-{
-  Glib::RefPtr<StatusIcon> status_icon( new StatusIcon() );
-  status_icon->set_from_file(filename);
-  return status_icon;
-}
-
-bool StatusIcon::get_geometry(Glib::RefPtr<Gdk::Screen>& screen, Gdk::Rectangle& area, Orientation& orientation)
-{
-  GdkScreen* cscreen = 0;
-  GdkRectangle carea;
-  const bool result = gtk_status_icon_get_geometry(const_cast<GtkStatusIcon*>(gobj()), &cscreen, &carea, (GtkOrientation*)(&orientation));
-
-  if(cscreen)
-    screen = Glib::wrap(cscreen);
-
-  *(area.gobj()) = carea;
-
-  return result;
-}
-
-
-} // namespace Gtk
-
-
-namespace
-{
-
-
-static gboolean StatusIcon_signal_size_changed_callback(GtkStatusIcon* self, gint p0,void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< bool,int > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        return static_cast<int>((*static_cast<SlotType*>(slot))(p0
-));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-
-static gboolean StatusIcon_signal_size_changed_notify_callback(GtkStatusIcon* self, gint p0, void* data)
-{
-  using namespace Gtk;
-  typedef sigc::slot< void,int > SlotType;
-
-  // Do not try to call a signal on a disassociated wrapper.
-  if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(p0
-);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-
-static const Glib::SignalProxyInfo StatusIcon_signal_size_changed_info =
-{
-  "size_changed",
-  (GCallback) &StatusIcon_signal_size_changed_callback,
-  (GCallback) &StatusIcon_signal_size_changed_notify_callback
-};
-
-
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gtk::StatusIcon> wrap(GtkStatusIcon* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::StatusIcon>( dynamic_cast<Gtk::StatusIcon*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& StatusIcon_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_ = &StatusIcon_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(gtk_status_icon_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void StatusIcon_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->size_changed = &size_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-gboolean StatusIcon_Class::size_changed_callback(GtkStatusIcon* self, gint 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_())
-  {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    try // Trap C++ exceptions which would normally be lost because this is a C callback.
-    {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-      // Call the virtual member method, which derived classes might override.
-      return static_cast<int>(obj->on_size_changed(p0
-));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
-    }
-    catch(...)
-    {
-      Glib::exception_handlers_invoke();
-    }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
-  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->size_changed)
-      return (*base->size_changed)(self, p0);
-  }
-
-  typedef gboolean RType;
-  return RType();
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* StatusIcon_Class::wrap_new(GObject* object)
-{
-  return new StatusIcon((GtkStatusIcon*)object);
-}
-
-
-/* The implementation: */
-
-GtkStatusIcon* StatusIcon::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-StatusIcon::StatusIcon(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-StatusIcon::StatusIcon(GtkStatusIcon* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-StatusIcon::~StatusIcon()
-{}
-
-
-StatusIcon::CppClassType StatusIcon::statusicon_class_; // initialize static member
-
-GType StatusIcon::get_type()
-{
-  return statusicon_class_.init().get_type();
-}
-
-GType StatusIcon::get_base_type()
-{
-  return gtk_status_icon_get_type();
-}
-
-
-StatusIcon::StatusIcon()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(statusicon_class_.init()))
-{
-  }
-
-StatusIcon::StatusIcon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(statusicon_class_.init(), "pixbuf", Glib::unwrap(pixbuf), (char*) 0))
-{
-  }
-
-StatusIcon::StatusIcon(const StockID& stock)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(statusicon_class_.init(), "stock", (stock).get_c_str(), (char*) 0))
-{
-  }
-
-StatusIcon::StatusIcon(const Glib::ustring& icon_name)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(statusicon_class_.init(), "icon_name", icon_name.c_str(), (char*) 0))
-{
-  }
-
-Glib::RefPtr<StatusIcon> StatusIcon::create(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
-{
-  return Glib::RefPtr<StatusIcon>( new StatusIcon(pixbuf) );
-}
-Glib::RefPtr<StatusIcon> StatusIcon::create(const StockID& stock_id)
-{
-  return Glib::RefPtr<StatusIcon>( new StatusIcon(stock_id) );
-}
-Glib::RefPtr<StatusIcon> StatusIcon::create(const Glib::ustring& icon_name)
-{
-  return Glib::RefPtr<StatusIcon>( new StatusIcon(icon_name) );
-}
-void StatusIcon::set(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
-{
-gtk_status_icon_set_from_pixbuf(gobj(), Glib::unwrap(pixbuf)); 
-}
-
-void StatusIcon::set_from_file(const Glib::ustring& filename)
-{
-gtk_status_icon_set_from_file(gobj(), filename.c_str()); 
-}
-
-void StatusIcon::set(const StockID& stock_id)
-{
-gtk_status_icon_set_from_stock(gobj(), (stock_id).get_c_str()); 
-}
-
-void StatusIcon::set(const Glib::ustring& icon_name)
-{
-gtk_status_icon_set_from_icon_name(gobj(), icon_name.c_str()); 
-}
-
-ImageType StatusIcon::get_storage_type() const
-{
-  return ((ImageType)(gtk_status_icon_get_storage_type(const_cast<GtkStatusIcon*>(gobj()))));
-}
-
-Glib::RefPtr<Gdk::Pixbuf> StatusIcon::get_pixbuf()
-{
-  return Glib::wrap(gtk_status_icon_get_pixbuf(gobj()));
-}
-
-Glib::RefPtr<const Gdk::Pixbuf> StatusIcon::get_pixbuf() const
-{
-  return const_cast<StatusIcon*>(this)->get_pixbuf();
-}
-
-StockID StatusIcon::get_stock() const
-{
-  return StockID(gtk_status_icon_get_stock(const_cast<GtkStatusIcon*>(gobj())));
-}
-
-Glib::ustring StatusIcon::get_icon_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_status_icon_get_icon_name(const_cast<GtkStatusIcon*>(gobj())));
-}
-
-int StatusIcon::get_size() const
-{
-  return gtk_status_icon_get_size(const_cast<GtkStatusIcon*>(gobj()));
-}
-
-void StatusIcon::set_tooltip(const Glib::ustring& tooltip_text)
-{
-gtk_status_icon_set_tooltip(gobj(), tooltip_text.c_str()); 
-}
-
-void StatusIcon::set_visible(bool visible)
-{
-gtk_status_icon_set_visible(gobj(), static_cast<int>(visible)); 
-}
-
-bool StatusIcon::get_visible() const
-{
-  return gtk_status_icon_get_visible(const_cast<GtkStatusIcon*>(gobj()));
-}
-
-void StatusIcon::set_blinking(bool blinking)
-{
-gtk_status_icon_set_blinking(gobj(), static_cast<int>(blinking)); 
-}
-
-bool StatusIcon::get_blinking() const
-{
-  return gtk_status_icon_get_blinking(const_cast<GtkStatusIcon*>(gobj()));
-}
-
-bool StatusIcon::is_embedded() const
-{
-  return gtk_status_icon_is_embedded(const_cast<GtkStatusIcon*>(gobj()));
-}
-
-
-Glib::SignalProxy1< bool,int > StatusIcon::signal_size_changed()
-{
-  return Glib::SignalProxy1< bool,int >(this, &StatusIcon_signal_size_changed_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > StatusIcon::property_pixbuf() 
-{
-  return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > StatusIcon::property_pixbuf() const
-{
-  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_WriteOnly<std::string> StatusIcon::property_file() 
-{
-  return Glib::PropertyProxy_WriteOnly<std::string>(this, "file");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<StockID> StatusIcon::property_stock() 
-{
-  return Glib::PropertyProxy<StockID>(this, "stock");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<StockID> StatusIcon::property_stock() const
-{
-  return Glib::PropertyProxy_ReadOnly<StockID>(this, "stock");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> StatusIcon::property_icon_name() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "icon-name");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> StatusIcon::property_icon_name() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "icon-name");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<ImageType> StatusIcon::property_storage_type() const
-{
-  return Glib::PropertyProxy_ReadOnly<ImageType>(this, "storage-type");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<int> StatusIcon::property_size() const
-{
-  return Glib::PropertyProxy_ReadOnly<int>(this, "size");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> StatusIcon::property_blinking() 
-{
-  return Glib::PropertyProxy<bool>(this, "blinking");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> StatusIcon::property_blinking() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "blinking");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-bool Gtk::StatusIcon::on_size_changed(int size)
-{
-  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->size_changed)
-    return (*base->size_changed)(gobj(),size);
-
-  typedef bool RType;
-  return RType();
-}
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
diff --git a/libs/gtkmm2/gtk/gtkmm/statusicon.h b/libs/gtkmm2/gtk/gtkmm/statusicon.h
deleted file mode 100644
index c3842c053d..0000000000
--- a/libs/gtkmm2/gtk/gtkmm/statusicon.h
+++ /dev/null
@@ -1,366 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_STATUSICON_H
-#define _GTKMM_STATUSICON_H
-
-
-#include <glibmm.h>
-
-/* $Id: statusicon.hg,v 1.6 2006/07/05 16:59:28 murrayc Exp $ */
-
-/* Copyright (C) 2005 The gtkmm 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/image.h> //For ImageType.
-#include <gtkmm/stockid.h>
-#include <gdkmm/pixbuf.h>
-#include <gdkmm/types.h>
-#include <gtkmm/object.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkStatusIcon GtkStatusIcon;
-typedef struct _GtkStatusIconClass GtkStatusIconClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{ class StatusIcon_Class; } // namespace Gtk
-namespace Gtk
-{
-
-/** The "system tray" or notification area is normally used for transient icons that indicate some 
- * special state. For example, a system tray icon might appear to tell the user that they have new 
- * mail, or have an incoming instant message, or something along those lines. The basic idea is 
- * that creating an icon in the notification area is less annoying than popping up a dialog.
- *
- * A StatusIcon object can be used to display an icon in a "system tray". The icon can have a 
- * tooltip, and the user can interact with it by activating it or popping up a context menu. 
- * Critical information should not solely be displayed in a StatusIcon, since it may not be 
- * visible (e.g. when the user doesn't have a notification area on his panel). This can be checked 
- * with is_embedded().
- *
- * On X11, the implementation follows the freedesktop.org "System Tray" specification.  
- * Implementations of the "tray" side of this specification can be found e.g. in the GNOME and KDE 
- * panel applications. 
- *
- * @newin2p10
- */
-
-class StatusIcon : public Glib::Object
-{
-   
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef StatusIcon CppObjectType;
-  typedef StatusIcon_Class CppClassType;
-  typedef GtkStatusIcon BaseObjectType;
-  typedef GtkStatusIconClass BaseClassType;
-
-private:  friend class StatusIcon_Class;
-  static CppClassType statusicon_class_;
-
-private:
-  // noncopyable
-  StatusIcon(const StatusIcon&);
-  StatusIcon& operator=(const StatusIcon&);
-
-protected:
-  explicit StatusIcon(const Glib::ConstructParams& construct_params);
-  explicit StatusIcon(GtkStatusIcon* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~StatusIcon();
-
-#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 GObject.
-  GtkStatusIcon*       gobj()       { return reinterpret_cast<GtkStatusIcon*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkStatusIcon* gobj() const { return reinterpret_cast<GtkStatusIcon*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkStatusIcon* gobj_copy();
-
-private:
-
-protected:
-  StatusIcon();
-  
-  explicit StatusIcon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
-  explicit StatusIcon(const StockID& stock);
-  explicit StatusIcon(const Glib::ustring& icon_name);
-
-public:
-  /** Creates a new Gtk::StatusIcon object.
-   * @return A Glib::RefPtr<> to a newly created Gtk::StatusIcon object.
-   */
-  
-  static Glib::RefPtr<StatusIcon> create(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
-
-  
-  static Glib::RefPtr<StatusIcon> create(const StockID& stock_id);
-
-  
-  static Glib::RefPtr<StatusIcon> create(const Glib::ustring& icon_name);
-
-
- /** Creates a status icon displaying the file @a filename. 
-  * The image will be scaled down to fit in the available 
-  * space in the notification area, if necessary.
-  * 
-  * @param filename A filename.
-  * @result A new StatusIcon
-  *
-  * @newin2p10
-  */
-  static Glib::RefPtr<StatusIcon> create_from_file(const std::string& filename);
-  
-
-  void set(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
-  
-  void set_from_file(const Glib::ustring& filename);
-  
-  void set(const StockID& stock_id);
-  
-  void set(const Glib::ustring& icon_name);
-
-  
-  ImageType get_storage_type() const;
-
-  
-  Glib::RefPtr<Gdk::Pixbuf> get_pixbuf();
-  
-  Glib::RefPtr<const Gdk::Pixbuf> get_pixbuf() const;
-
-  
-  StockID get_stock() const;
-  
-  Glib::ustring get_icon_name() const;
-
-  
-  int get_size() const;
-
-  
-  void set_tooltip(const Glib::ustring& tooltip_text);
-
-  
-  void set_visible(bool visible = true);
-  
-  bool get_visible() const;
-  
-  void set_blinking(bool blinking = true);
-  
-  bool get_blinking() const;
-
-  
-  bool is_embedded() const;
-
-
-  //In gtk_status_icon_get_geometry(), any of the parameters may be NULL,
-  //but we don't need 6 different overloads, with different parameters.
-  //But we can add some if there are common cases.
-
-  /** Obtains information about the location of the status icon
-   * on screen. This information can be used to e.g. position 
-   * popups like notification bubbles. 
-   * See gtk_status_icon_position_menu() for a more convenient 
-   * alternative for positioning menus.
-   *
-   * Note that some platforms do not allow GTK+ to provide 
-   * this information.
-   *
-   * @param screen: The screen.
-   * @param area The area occupied by the status icon.
-   * @param orientation The orientation of the panel  in which the status icon is embedded. A panel 
-   * at the top or bottom of the screen is horizontal, a panel at the left or right is vertical.
-   * @result true if the location information has been filled in.
-   *
-   * @newin2p10
-   */
-  bool get_geometry(Glib::RefPtr<Gdk::Screen>& screen, Gdk::Rectangle& area, Orientation& orientation);
-  
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** A GdkPixbuf to display.
-   *
-   * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** A GdkPixbuf to display.
-   *
-   * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Filename to load and display.
-   *
-   * 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<std::string> property_file() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Stock ID for a stock image to display.
-   *
-   * 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<StockID> property_stock() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Stock ID for a stock image to display.
-   *
-   * 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<StockID> property_stock() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The name of the icon from the icon theme.
-   *
-   * 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_icon_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** The name of the icon from the icon theme.
-   *
-   * 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_icon_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The representation being used for image data.
-   *
-   * 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<ImageType> property_storage_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The size of the icon.
-   *
-   * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether or not the status icon is blinking.
-   *
-   * 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_blinking() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether or not the status icon is blinking.
-   *
-   * 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_blinking() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
-/**
-   * @par Prototype:
-   * <tt>bool %size_changed(int size)</tt>
-   */
-
-  Glib::SignalProxy1< bool,int > signal_size_changed();
-
-   //Keybinding signal.
-   //Keybinding signal.  
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  virtual bool on_size_changed(int size);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-  /** @relates Gtk::StatusIcon
-   * @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<Gtk::StatusIcon> wrap(GtkStatusIcon* object, bool take_copy = false);
-}
-
-
-#endif /* _GTKMM_STATUSICON_H */
-
diff --git a/libs/gtkmm2/gtk/gtkmm/stock.cc b/libs/gtkmm2/gtk/gtkmm/stock.cc
index 26ba2305a5..eb13cc0ef8 100644
--- a/libs/gtkmm2/gtk/gtkmm/stock.cc
+++ b/libs/gtkmm2/gtk/gtkmm/stock.cc
@@ -63,8 +63,6 @@ const Gtk::BuiltinStockID FILE = { GTK_STOCK_FILE };
 const Gtk::BuiltinStockID FIND = { GTK_STOCK_FIND };
 const Gtk::BuiltinStockID FIND_AND_REPLACE = { GTK_STOCK_FIND_AND_REPLACE };
 const Gtk::BuiltinStockID FLOPPY = { GTK_STOCK_FLOPPY };
-const Gtk::BuiltinStockID FULLSCREEN = { GTK_STOCK_FULLSCREEN };
-const Gtk::BuiltinStockID LEAVE_FULLSCREEN = { GTK_STOCK_LEAVE_FULLSCREEN };
 const Gtk::BuiltinStockID GOTO_BOTTOM = { GTK_STOCK_GOTO_BOTTOM };
 const Gtk::BuiltinStockID GOTO_FIRST = { GTK_STOCK_GOTO_FIRST };
 const Gtk::BuiltinStockID GOTO_LAST = { GTK_STOCK_GOTO_LAST };
@@ -77,7 +75,6 @@ const Gtk::BuiltinStockID HARDDISK = { GTK_STOCK_HARDDISK };
 const Gtk::BuiltinStockID HELP = { GTK_STOCK_HELP };
 const Gtk::BuiltinStockID HOME = { GTK_STOCK_HOME };
 const Gtk::BuiltinStockID INDEX = { GTK_STOCK_INDEX };
-const Gtk::BuiltinStockID INFO = { GTK_STOCK_INFO };
 const Gtk::BuiltinStockID INDENT = { GTK_STOCK_INDENT };
 const Gtk::BuiltinStockID UNINDENT = { GTK_STOCK_UNINDENT };
 const Gtk::BuiltinStockID ITALIC = { GTK_STOCK_ITALIC };
diff --git a/libs/gtkmm2/gtk/gtkmm/stock.h b/libs/gtkmm2/gtk/gtkmm/stock.h
index 28d312b45e..e7f3888241 100644
--- a/libs/gtkmm2/gtk/gtkmm/stock.h
+++ b/libs/gtkmm2/gtk/gtkmm/stock.h
@@ -86,8 +86,6 @@ extern GTKMM_API const Gtk::BuiltinStockID FILE;             /*!< @image html st
 extern GTKMM_API const Gtk::BuiltinStockID FIND;             /*!< @image html stock_search_24.png              */
 extern GTKMM_API const Gtk::BuiltinStockID FIND_AND_REPLACE; /*!< @image html stock_search_replace_24.png      */
 extern GTKMM_API const Gtk::BuiltinStockID FLOPPY;           /*!< @image html stock_save_24.png                */
-extern GTKMM_API const Gtk::BuiltinStockID FULLSCREEN;       /*!< @image html stock_fullscreen_24.png                */
-extern GTKMM_API const Gtk::BuiltinStockID LEAVE_FULLSCREEN; /*!< @image html stock_leave_fullscreen_24.png                */
 extern GTKMM_API const Gtk::BuiltinStockID GOTO_BOTTOM;      /*!< @image html stock_bottom_24.png              */
 extern GTKMM_API const Gtk::BuiltinStockID GOTO_FIRST;       /*!< @image html stock_first_24.png               */
 extern GTKMM_API const Gtk::BuiltinStockID GOTO_LAST;        /*!< @image html stock_last_24.png                */
@@ -100,7 +98,6 @@ extern GTKMM_API const Gtk::BuiltinStockID HARDDISK;         /*!< @image html st
 extern GTKMM_API const Gtk::BuiltinStockID HELP;             /*!< @image html stock_help_24.png                */
 extern GTKMM_API const Gtk::BuiltinStockID HOME;             /*!< @image html stock_home_24.png                */
 extern GTKMM_API const Gtk::BuiltinStockID INDEX;            /*!< @image html stock_index_24.png               */
-extern GTKMM_API const Gtk::BuiltinStockID INFO;            /*!< @image html stock_info_24.png               */
 extern GTKMM_API const Gtk::BuiltinStockID INDENT;           /*!< @image html stock_indent_24.png              */
 extern GTKMM_API const Gtk::BuiltinStockID UNINDENT;         /*!< @image html stock_unindent_24.png            */
 extern GTKMM_API const Gtk::BuiltinStockID ITALIC;           /*!< @image html stock_text_italic_24.png         */
diff --git a/libs/gtkmm2/gtk/gtkmm/stockitem.cc b/libs/gtkmm2/gtk/gtkmm/stockitem.cc
index 03b0dd13d2..3a2c10687e 100644
--- a/libs/gtkmm2/gtk/gtkmm/stockitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/stockitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/stockitem.h>
 #include <gtkmm/private/stockitem_p.h>
 
@@ -136,31 +135,31 @@ GtkStockItem* StockItem::gobj_copy() const
 }
 
 
- StockID StockItem::get_stock_id() const
+StockID StockItem::get_stock_id() const
 {
   return StockID(gobj()->stock_id);
 }
- 
- Glib::ustring StockItem::get_label() const
+
+Glib::ustring StockItem::get_label() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->label);
 }
- 
- Gdk::ModifierType StockItem::get_modifier() const
+
+Gdk::ModifierType StockItem::get_modifier() const
 {
   return ((Gdk::ModifierType)(gobj()->modifier));
 }
- 
- guint StockItem::get_keyval() const
+
+guint StockItem::get_keyval() const
 {
   return gobj()->keyval;
 }
- 
- Glib::ustring StockItem::get_translation_domain() const
+
+Glib::ustring StockItem::get_translation_domain() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->translation_domain);
 }
- 
+
 
 } // namespace Gtk
 
diff --git a/libs/gtkmm2/gtk/gtkmm/stockitem.h b/libs/gtkmm2/gtk/gtkmm/stockitem.h
index d674f99ced..f500c0f12a 100644
--- a/libs/gtkmm2/gtk/gtkmm/stockitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/stockitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_STOCKITEM_H
 #define _GTKMM_STOCKITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -74,12 +73,12 @@ public:
             Gdk::ModifierType modifier = Gdk::ModifierType(0), unsigned int keyval = 0,
             const Glib::ustring& translation_domain = Glib::ustring());
 
-   StockID get_stock_id() const;
-    Glib::ustring get_label() const;
-    Gdk::ModifierType get_modifier() const;
-    guint get_keyval() const;
-    Glib::ustring get_translation_domain() const;
- 
+  StockID get_stock_id() const;
+  Glib::ustring get_label() const;
+  Gdk::ModifierType get_modifier() const;
+  guint get_keyval() const;
+  Glib::ustring get_translation_domain() const;
+
   static bool lookup(const Gtk::StockID& stock_id, Gtk::StockItem& item);
 
 
@@ -100,6 +99,5 @@ Gtk::StockItem wrap(GtkStockItem* object, bool take_copy = false);
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_STOCKITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/style.cc b/libs/gtkmm2/gtk/gtkmm/style.cc
index a6cc2a2cb5..ed4d97fcbc 100644
--- a/libs/gtkmm2/gtk/gtkmm/style.cc
+++ b/libs/gtkmm2/gtk/gtkmm/style.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/style.h>
 #include <gtkmm/private/style_p.h>
 
@@ -154,8 +153,6 @@ Glib::RefPtr<const Gdk::GC> Style::get_base_gc(StateType state_type) const
   return Glib::wrap(gobj()->base_gc[state_type], true);
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 Gdk::Color Style::get_background(StateType state_type) const
 {
   GdkColor* pGdkColor = const_cast<GdkColor*>(&(gobj()->bg[state_type]));
@@ -175,18 +172,6 @@ void Style::set_bg_pixmap(StateType state_type, const Glib::RefPtr<Gdk::Pixmap>&
   if(old_pixmap)
     g_object_unref(old_pixmap);
 }
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-void Style::set_bg_pixmap(StateType state_type, const Glib::RefPtr<const Gdk::Pixmap>& pixmap)
-{
-  GdkPixmap *const old_pixmap = gobj()->bg_pixmap[state_type];
-  Glib::RefPtr<Gdk::Pixmap> pixmap_unconst = Glib::RefPtr<Gdk::Pixmap>::cast_const(pixmap);
-  gobj()->bg_pixmap[state_type] = Glib::unwrap_copy(pixmap_unconst); //unwrap_copy() needs a non-const.
-
-  if(old_pixmap)
-    g_object_unref(old_pixmap);
-}
 
 Glib::RefPtr<Gdk::Pixmap> Style::get_bg_pixmap(StateType state_type)
 {
@@ -230,21 +215,13 @@ void Style::paint_polygon(const Glib::RefPtr<Gdk::Window>&      window,
       fill);
 }
 
-IconSet Style::lookup_icon_set(const Gtk::StockID& stock_id)
-{
-  GtkIconSet* pIconSet = gtk_style_lookup_icon_set(gobj(), stock_id.get_c_str());
-  return IconSet(pIconSet, true); //true = take_copy.
-
-}
-
 } // namespace Gtk
 
 
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Style_signal_realize_info =
+const Glib::SignalProxyInfo Style_signal_realize_info =
 {
   "realize",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -252,14 +229,13 @@ static const Glib::SignalProxyInfo Style_signal_realize_info =
 };
 
 
-static const Glib::SignalProxyInfo Style_signal_unrealize_info =
+const Glib::SignalProxyInfo Style_signal_unrealize_info =
 {
   "unrealize",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -306,7 +282,6 @@ void Style_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->realize = &realize_vfunc_callback;
   klass->unrealize = &unrealize_vfunc_callback;
   klass->copy = &copy_vfunc_callback;
@@ -335,15 +310,10 @@ void Style_Class::class_init_function(void* g_class, void* class_data)
   klass->draw_expander = &draw_expander_vfunc_callback;
   klass->draw_layout = &draw_layout_vfunc_callback;
   klass->draw_resize_grip = &draw_resize_grip_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->realize = &realize_callback;
   klass->unrealize = &unrealize_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Style_Class::realize_vfunc_callback(GtkStyle* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -356,19 +326,15 @@ void Style_Class::realize_vfunc_callback(GtkStyle* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->realize_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -381,6 +347,7 @@ void Style_Class::realize_vfunc_callback(GtkStyle* self)
       (*base->realize)(self);
   }
 }
+
 void Style_Class::unrealize_vfunc_callback(GtkStyle* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -393,19 +360,15 @@ void Style_Class::unrealize_vfunc_callback(GtkStyle* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->unrealize_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -418,6 +381,7 @@ void Style_Class::unrealize_vfunc_callback(GtkStyle* self)
       (*base->unrealize)(self);
   }
 }
+
 void Style_Class::copy_vfunc_callback(GtkStyle* self, GtkStyle* src)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -430,20 +394,16 @@ void Style_Class::copy_vfunc_callback(GtkStyle* self, GtkStyle* src)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->copy_vfunc(Glib::wrap(src, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -456,6 +416,7 @@ void Style_Class::copy_vfunc_callback(GtkStyle* self, GtkStyle* src)
       (*base->copy)(self, src);
   }
 }
+
 GtkStyle* Style_Class::clone_vfunc_callback(GtkStyle* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -468,19 +429,15 @@ GtkStyle* Style_Class::clone_vfunc_callback(GtkStyle* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->clone_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -496,6 +453,7 @@ GtkStyle* Style_Class::clone_vfunc_callback(GtkStyle* self)
   typedef GtkStyle* RType;
   return RType();
 }
+
 void Style_Class::init_from_rc_vfunc_callback(GtkStyle* self, GtkRcStyle* rc_style)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -508,20 +466,16 @@ void Style_Class::init_from_rc_vfunc_callback(GtkStyle* self, GtkRcStyle* rc_sty
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->init_from_rc_vfunc(Glib::wrap(rc_style)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -534,6 +488,7 @@ void Style_Class::init_from_rc_vfunc_callback(GtkStyle* self, GtkRcStyle* rc_sty
       (*base->init_from_rc)(self, rc_style);
   }
 }
+
 void Style_Class::set_background_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -546,21 +501,17 @@ void Style_Class::set_background_vfunc_callback(GtkStyle* self, GdkWindow* windo
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_background_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -573,6 +524,7 @@ void Style_Class::set_background_vfunc_callback(GtkStyle* self, GdkWindow* windo
       (*base->set_background)(self, window, state_type);
   }
 }
+
 GdkPixbuf* Style_Class::render_icon_vfunc_callback(GtkStyle* self, const GtkIconSource* source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget* widget, const gchar* detail)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -585,10 +537,8 @@ GdkPixbuf* Style_Class::render_icon_vfunc_callback(GtkStyle* self, const GtkIcon
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->render_icon_vfunc(Glib::wrap(const_cast<GtkIconSource*>(source), true)
 , ((TextDirection)(direction))
@@ -597,13 +547,11 @@ GdkPixbuf* Style_Class::render_icon_vfunc_callback(GtkStyle* self, const GtkIcon
 , Glib::wrap(widget)
 , Glib::convert_const_gchar_ptr_to_ustring(detail)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -619,6 +567,7 @@ GdkPixbuf* Style_Class::render_icon_vfunc_callback(GtkStyle* self, const GtkIcon
   typedef GdkPixbuf* RType;
   return RType();
 }
+
 void Style_Class::draw_hline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x1, gint x2, gint y)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -631,10 +580,8 @@ void Style_Class::draw_hline_vfunc_callback(GtkStyle* self, GdkWindow* window, G
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_hline_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -645,13 +592,11 @@ void Style_Class::draw_hline_vfunc_callback(GtkStyle* self, GdkWindow* window, G
 , x2
 , y
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -664,6 +609,7 @@ void Style_Class::draw_hline_vfunc_callback(GtkStyle* self, GdkWindow* window, G
       (*base->draw_hline)(self, window, state_type, area, widget, detail, x1, x2, y);
   }
 }
+
 void Style_Class::draw_vline_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint y1, gint y2, gint x)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -676,10 +622,8 @@ void Style_Class::draw_vline_vfunc_callback(GtkStyle* self, GdkWindow* window, G
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_vline_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -690,13 +634,11 @@ void Style_Class::draw_vline_vfunc_callback(GtkStyle* self, GdkWindow* window, G
 , y2
 , x
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -709,6 +651,7 @@ void Style_Class::draw_vline_vfunc_callback(GtkStyle* self, GdkWindow* window, G
       (*base->draw_vline)(self, window, state_type, area, widget, detail, y1, y2, x);
   }
 }
+
 void Style_Class::draw_shadow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -721,10 +664,8 @@ void Style_Class::draw_shadow_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_shadow_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -737,13 +678,11 @@ void Style_Class::draw_shadow_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -756,6 +695,7 @@ void Style_Class::draw_shadow_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_shadow)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_polygon_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkPoint* point, gint npoints, gboolean fill)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -768,10 +708,8 @@ void Style_Class::draw_polygon_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_polygon_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -782,13 +720,11 @@ void Style_Class::draw_polygon_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , point, npoints
 , fill
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -801,6 +737,7 @@ void Style_Class::draw_polygon_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_polygon)(self, window, state_type, shadow_type, area, widget, detail, point, npoints, fill);
   }
 }
+
 void Style_Class::draw_arrow_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GtkArrowType arrow_type, gboolean fill, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -813,10 +750,8 @@ void Style_Class::draw_arrow_vfunc_callback(GtkStyle* self, GdkWindow* window, G
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_arrow_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -831,13 +766,11 @@ void Style_Class::draw_arrow_vfunc_callback(GtkStyle* self, GdkWindow* window, G
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -850,6 +783,7 @@ void Style_Class::draw_arrow_vfunc_callback(GtkStyle* self, GdkWindow* window, G
       (*base->draw_arrow)(self, window, state_type, shadow_type, area, widget, detail, arrow_type, fill, x, y, width, height);
   }
 }
+
 void Style_Class::draw_diamond_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -862,10 +796,8 @@ void Style_Class::draw_diamond_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_diamond_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -878,13 +810,11 @@ void Style_Class::draw_diamond_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -897,6 +827,7 @@ void Style_Class::draw_diamond_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_diamond)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_string_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, const gchar* string)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -909,10 +840,8 @@ void Style_Class::draw_string_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_string_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -923,13 +852,11 @@ void Style_Class::draw_string_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , y
 , Glib::convert_const_gchar_ptr_to_ustring(string)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -942,6 +869,7 @@ void Style_Class::draw_string_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_string)(self, window, state_type, area, widget, detail, x, y, string);
   }
 }
+
 void Style_Class::draw_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -954,10 +882,8 @@ void Style_Class::draw_box_vfunc_callback(GtkStyle* self, GdkWindow* window, Gtk
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_box_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -970,13 +896,11 @@ void Style_Class::draw_box_vfunc_callback(GtkStyle* self, GdkWindow* window, Gtk
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -989,6 +913,7 @@ void Style_Class::draw_box_vfunc_callback(GtkStyle* self, GdkWindow* window, Gtk
       (*base->draw_box)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_flat_box_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1001,10 +926,8 @@ void Style_Class::draw_flat_box_vfunc_callback(GtkStyle* self, GdkWindow* window
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_flat_box_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1017,13 +940,11 @@ void Style_Class::draw_flat_box_vfunc_callback(GtkStyle* self, GdkWindow* window
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1036,6 +957,7 @@ void Style_Class::draw_flat_box_vfunc_callback(GtkStyle* self, GdkWindow* window
       (*base->draw_flat_box)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_check_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1048,10 +970,8 @@ void Style_Class::draw_check_vfunc_callback(GtkStyle* self, GdkWindow* window, G
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_check_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1064,13 +984,11 @@ void Style_Class::draw_check_vfunc_callback(GtkStyle* self, GdkWindow* window, G
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1083,6 +1001,7 @@ void Style_Class::draw_check_vfunc_callback(GtkStyle* self, GdkWindow* window, G
       (*base->draw_check)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_option_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1095,10 +1014,8 @@ void Style_Class::draw_option_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_option_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1111,13 +1028,11 @@ void Style_Class::draw_option_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1130,6 +1045,7 @@ void Style_Class::draw_option_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_option)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_tab_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1142,10 +1058,8 @@ void Style_Class::draw_tab_vfunc_callback(GtkStyle* self, GdkWindow* window, Gtk
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_tab_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1158,13 +1072,11 @@ void Style_Class::draw_tab_vfunc_callback(GtkStyle* self, GdkWindow* window, Gtk
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1177,6 +1089,7 @@ void Style_Class::draw_tab_vfunc_callback(GtkStyle* self, GdkWindow* window, Gtk
       (*base->draw_tab)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_shadow_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1189,10 +1102,8 @@ void Style_Class::draw_shadow_gap_vfunc_callback(GtkStyle* self, GdkWindow* wind
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_shadow_gap_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1208,13 +1119,11 @@ void Style_Class::draw_shadow_gap_vfunc_callback(GtkStyle* self, GdkWindow* wind
 , gap_x
 , gap_width
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1227,6 +1136,7 @@ void Style_Class::draw_shadow_gap_vfunc_callback(GtkStyle* self, GdkWindow* wind
       (*base->draw_shadow_gap)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
   }
 }
+
 void Style_Class::draw_box_gap_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side, gint gap_x, gint gap_width)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1239,10 +1149,8 @@ void Style_Class::draw_box_gap_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_box_gap_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1258,13 +1166,11 @@ void Style_Class::draw_box_gap_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , gap_x
 , gap_width
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1277,6 +1183,7 @@ void Style_Class::draw_box_gap_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_box_gap)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
   }
 }
+
 void Style_Class::draw_extension_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkPositionType gap_side)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1289,10 +1196,8 @@ void Style_Class::draw_extension_vfunc_callback(GtkStyle* self, GdkWindow* windo
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_extension_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1306,13 +1211,11 @@ void Style_Class::draw_extension_vfunc_callback(GtkStyle* self, GdkWindow* windo
 , height
 , ((PositionType)(gap_side))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1325,6 +1228,7 @@ void Style_Class::draw_extension_vfunc_callback(GtkStyle* self, GdkWindow* windo
       (*base->draw_extension)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side);
   }
 }
+
 void Style_Class::draw_focus_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1337,10 +1241,8 @@ void Style_Class::draw_focus_vfunc_callback(GtkStyle* self, GdkWindow* window, G
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_focus_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1352,13 +1254,11 @@ void Style_Class::draw_focus_vfunc_callback(GtkStyle* self, GdkWindow* window, G
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1371,6 +1271,7 @@ void Style_Class::draw_focus_vfunc_callback(GtkStyle* self, GdkWindow* window, G
       (*base->draw_focus)(self, window, state_type, area, widget, detail, x, y, width, height);
   }
 }
+
 void Style_Class::draw_slider_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1383,10 +1284,8 @@ void Style_Class::draw_slider_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_slider_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1400,13 +1299,11 @@ void Style_Class::draw_slider_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , height
 , ((Orientation)(orientation))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1419,6 +1316,7 @@ void Style_Class::draw_slider_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_slider)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
   }
 }
+
 void Style_Class::draw_handle_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, gint width, gint height, GtkOrientation orientation)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1431,10 +1329,8 @@ void Style_Class::draw_handle_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_handle_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1448,13 +1344,11 @@ void Style_Class::draw_handle_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , height
 , ((Orientation)(orientation))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1467,6 +1361,7 @@ void Style_Class::draw_handle_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_handle)(self, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
   }
 }
+
 void Style_Class::draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, GtkExpanderStyle expander_style)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1479,10 +1374,8 @@ void Style_Class::draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_expander_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1493,13 +1386,11 @@ void Style_Class::draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window
 , y
 , ((ExpanderStyle)(expander_style))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1512,6 +1403,7 @@ void Style_Class::draw_expander_vfunc_callback(GtkStyle* self, GdkWindow* window
       (*base->draw_expander)(self, window, state_type, area, widget, detail, x, y, expander_style);
   }
 }
+
 void Style_Class::draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, gboolean use_text, GdkRectangle* area, GtkWidget* widget, const gchar* detail, gint x, gint y, PangoLayout* layout)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1524,10 +1416,8 @@ void Style_Class::draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_layout_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1539,13 +1429,11 @@ void Style_Class::draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window,
 , y
 , Glib::wrap(layout)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1558,6 +1446,7 @@ void Style_Class::draw_layout_vfunc_callback(GtkStyle* self, GdkWindow* window,
       (*base->draw_layout)(self, window, state_type, use_text, area, widget, detail, x, y, layout);
   }
 }
+
 void Style_Class::draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* window, GtkStateType state_type, GdkRectangle* area, GtkWidget* widget, const gchar* detail, GdkWindowEdge edge, gint x, gint y, gint width, gint height)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1570,10 +1459,8 @@ void Style_Class::draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* win
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_resize_grip_vfunc(Glib::wrap((GdkWindowObject*)(window), true)
 , ((Gtk::StateType)(state_type))
@@ -1586,13 +1473,11 @@ void Style_Class::draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* win
 , width
 , height
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1605,9 +1490,8 @@ void Style_Class::draw_resize_grip_vfunc_callback(GtkStyle* self, GdkWindow* win
       (*base->draw_resize_grip)(self, window, state_type, area, widget, detail, edge, x, y, width, height);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Style_Class::realize_callback(GtkStyle* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1620,19 +1504,15 @@ void Style_Class::realize_callback(GtkStyle* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_realize();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1645,6 +1525,7 @@ void Style_Class::realize_callback(GtkStyle* self)
       (*base->realize)(self);
   }
 }
+
 void Style_Class::unrealize_callback(GtkStyle* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1657,19 +1538,15 @@ void Style_Class::unrealize_callback(GtkStyle* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_unrealize();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1682,7 +1559,6 @@ void Style_Class::unrealize_callback(GtkStyle* self)
       (*base->unrealize)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Style_Class::wrap_new(GObject* object)
@@ -1817,37 +1693,37 @@ Gdk::Color Style::get_text_aa(StateType state) const
   return Gdk::Color(const_cast<GdkColor*>(&gobj()->text_aa[state]), true);
 }
 
- void Style::set_black(const Gdk::Color& value)
+void Style::set_black(const Gdk::Color& value)
 {
   gobj()->black = (*(value).gobj());
 }
- 
- Gdk::Color Style::get_black() const
+
+Gdk::Color Style::get_black() const
 {
   return Gdk::Color(const_cast<GdkColor*>(&(gobj()->black)), true);
 }
- 
- void Style::set_white(const Gdk::Color& value)
+
+void Style::set_white(const Gdk::Color& value)
 {
   gobj()->white = (*(value).gobj());
 }
- 
- Gdk::Color Style::get_white() const
+
+Gdk::Color Style::get_white() const
 {
   return Gdk::Color(const_cast<GdkColor*>(&(gobj()->white)), true);
 }
- 
- int Style::get_xthickness() const
+
+int Style::get_xthickness() const
 {
   return gobj()->xthickness;
 }
- 
- int Style::get_ythickness() const
+
+int Style::get_ythickness() const
 {
   return gobj()->ythickness;
 }
- 
- Glib::RefPtr<Gdk::GC> Style::get_black_gc()
+
+Glib::RefPtr<Gdk::GC> Style::get_black_gc()
 {
   Glib::RefPtr<Gdk::GC> ref_ptr(Glib::wrap(gobj()->black_gc));
 
@@ -1866,8 +1742,8 @@ Glib::RefPtr<const Gdk::GC> Style::get_black_gc() const
 
   return ref_ptr;
 }
- 
- Glib::RefPtr<Gdk::GC> Style::get_white_gc()
+
+Glib::RefPtr<Gdk::GC> Style::get_white_gc()
 {
   Glib::RefPtr<Gdk::GC> ref_ptr(Glib::wrap(gobj()->white_gc));
 
@@ -1886,100 +1762,100 @@ Glib::RefPtr<const Gdk::GC> Style::get_white_gc() const
 
   return ref_ptr;
 }
- 
+
 void Style::paint_arrow(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, ArrowType arrow_type, bool fill, int x, int y, int width, int height) const
 {
-gtk_paint_arrow(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), ((GtkArrowType)(arrow_type)), static_cast<int>(fill), x, y, width, height); 
+  gtk_paint_arrow(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), ((GtkArrowType)(arrow_type)), static_cast<int>(fill), x, y, width, height);
 }
 
 void Style::paint_box(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_box(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_box(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_box_gap(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) const
 {
-gtk_paint_box_gap(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)), gap_x, gap_width); 
+  gtk_paint_box_gap(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)), gap_x, gap_width);
 }
 
 void Style::paint_check(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_check(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_check(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_diamond(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_diamond(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_diamond(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_extension(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side) const
 {
-gtk_paint_extension(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side))); 
+  gtk_paint_extension(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)));
 }
 
 void Style::paint_flat_box(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_flat_box(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_flat_box(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_focus(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_focus(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_focus(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_handle(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) const
 {
-gtk_paint_handle(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height, ((GtkOrientation)(orientation))); 
+  gtk_paint_handle(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height, ((GtkOrientation)(orientation)));
 }
 
 void Style::paint_hline(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x1, int x2, int y) const
 {
-gtk_paint_hline(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x1, x2, y); 
+  gtk_paint_hline(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x1, x2, y);
 }
 
 void Style::paint_option(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_option(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_option(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_shadow(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_shadow(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_shadow(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_shadow_gap(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side, int gap_x, int gap_width) const
 {
-gtk_paint_shadow_gap(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)), gap_x, gap_width); 
+  gtk_paint_shadow_gap(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), const_cast<gchar*>(detail.c_str()), x, y, width, height, ((GtkPositionType)(gap_side)), gap_x, gap_width);
 }
 
 void Style::paint_slider(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) const
 {
-gtk_paint_slider(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height, ((GtkOrientation)(orientation))); 
+  gtk_paint_slider(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height, ((GtkOrientation)(orientation)));
 }
 
 void Style::paint_tab(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, int width, int height) const
 {
-gtk_paint_tab(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height); 
+  gtk_paint_tab(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), ((GtkShadowType)(shadow_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, width, height);
 }
 
 void Style::paint_vline(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int y1, int y2, int x) const
 {
-gtk_paint_vline(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), y1, y2, x); 
+  gtk_paint_vline(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), y1, y2, x);
 }
 
 void Style::paint_expander(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, ExpanderStyle expander_style) const
 {
-gtk_paint_expander(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, ((GtkExpanderStyle)(expander_style))); 
+  gtk_paint_expander(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, ((GtkExpanderStyle)(expander_style)));
 }
 
 void Style::paint_layout(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, bool use_text, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, int x, int y, const Glib::RefPtr<Pango::Layout>& layout) const
 {
-gtk_paint_layout(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), static_cast<int>(use_text), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, Glib::unwrap(layout)); 
+  gtk_paint_layout(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), static_cast<int>(use_text), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), x, y, Glib::unwrap(layout));
 }
 
 void Style::paint_resize_grip(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget& widget, const Glib::ustring& detail, Gdk::WindowEdge edge, int x, int y, int width, int height) const
 {
-gtk_paint_resize_grip(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), ((GdkWindowEdge)(edge)), x, y, width, height); 
+  gtk_paint_resize_grip(const_cast<GtkStyle*>(gobj()), Glib::unwrap(window), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), (widget).gobj(), detail.c_str(), ((GdkWindowEdge)(edge)), x, y, width, height);
 }
 
 Glib::RefPtr<Style> Style::copy()
@@ -1989,17 +1865,17 @@ Glib::RefPtr<Style> Style::copy()
 
 void Style::set_background(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type)
 {
-gtk_style_set_background(gobj(), Glib::unwrap(window), ((GtkStateType)(state_type))); 
+  gtk_style_set_background(gobj(), Glib::unwrap(window), ((GtkStateType)(state_type)));
 }
 
 void Style::apply_default_background(const Glib::RefPtr<Gdk::Window>& window, bool set_bg, Gtk::StateType state_type, const Gdk::Rectangle& area, int x, int y, int width, int height)
 {
-gtk_style_apply_default_background(gobj(), Glib::unwrap(window), static_cast<int>(set_bg), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), x, y, width, height); 
+  gtk_style_apply_default_background(gobj(), Glib::unwrap(window), static_cast<int>(set_bg), ((GtkStateType)(state_type)), const_cast<GdkRectangle*>(area.gobj()), x, y, width, height);
 }
 
-bool Style::lookup_color(const Glib::ustring& color_name, Gdk::Color& color) const
+IconSet Style::lookup_icon_set(const Gtk::StockID& stock_id)
 {
-  return gtk_style_lookup_color(const_cast<GtkStyle*>(gobj()), color_name.c_str(), (color).gobj());
+  return Glib::wrap(gtk_style_lookup_icon_set(gobj(), (stock_id).get_c_str()));
 }
 
 Glib::RefPtr<Gdk::Pixbuf> Style::render_icon(const IconSource& source, Gtk::TextDirection direction, Gtk::StateType state, Gtk::IconSize size, Gtk::Widget& widget, const Glib::ustring& detail)
@@ -2013,14 +1889,12 @@ Glib::SignalProxy0< void > Style::signal_realize()
   return Glib::SignalProxy0< void >(this, &Style_signal_realize_info);
 }
 
-
 Glib::SignalProxy0< void > Style::signal_unrealize()
 {
   return Glib::SignalProxy0< void >(this, &Style_signal_unrealize_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Style::on_realize()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2030,6 +1904,7 @@ void Gtk::Style::on_realize()
   if(base && base->realize)
     (*base->realize)(gobj());
 }
+
 void Gtk::Style::on_unrealize()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2039,9 +1914,8 @@ void Gtk::Style::on_unrealize()
   if(base && base->unrealize)
     (*base->unrealize)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::Style::realize_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2051,6 +1925,7 @@ void Gtk::Style::realize_vfunc()
   if(base && base->realize)
     (*base->realize)(gobj());
 }
+
 void Gtk::Style::unrealize_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2060,6 +1935,7 @@ void Gtk::Style::unrealize_vfunc()
   if(base && base->unrealize)
     (*base->unrealize)(gobj());
 }
+
 void Gtk::Style::copy_vfunc(const Glib::RefPtr<Style>& src) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2069,6 +1945,7 @@ void Gtk::Style::copy_vfunc(const Glib::RefPtr<Style>& src)
   if(base && base->copy)
     (*base->copy)(gobj(),Glib::unwrap(src));
 }
+
 Glib::RefPtr<Style> Gtk::Style::clone_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2081,6 +1958,7 @@ Glib::RefPtr<Style> Gtk::Style::clone_vfunc()
   typedef Glib::RefPtr<Style> RType;
   return RType();
 }
+
 void Gtk::Style::init_from_rc_vfunc(const Glib::RefPtr<RcStyle>& rc_style) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2090,6 +1968,7 @@ void Gtk::Style::init_from_rc_vfunc(const Glib::RefPtr<RcStyle>& rc_style)
   if(base && base->init_from_rc)
     (*base->init_from_rc)(gobj(),Glib::unwrap(rc_style));
 }
+
 void Gtk::Style::set_background_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2099,6 +1978,7 @@ void Gtk::Style::set_background_vfunc(const Glib::RefPtr<Gdk::Window>& window, G
   if(base && base->set_background)
     (*base->set_background)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)));
 }
+
 Glib::RefPtr<Gdk::Pixbuf> Gtk::Style::render_icon_vfunc(const IconSource& source, TextDirection direction, Gtk::StateType state, IconSize size, Widget* widget, const Glib::ustring& detail) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2111,6 +1991,7 @@ Glib::RefPtr<Gdk::Pixbuf> Gtk::Style::render_icon_vfunc(const IconSource& source
   typedef Glib::RefPtr<Gdk::Pixbuf> RType;
   return RType();
 }
+
 void Gtk::Style::draw_hline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x1, int x2, int y) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2120,6 +2001,7 @@ void Gtk::Style::draw_hline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::
   if(base && base->draw_hline)
     (*base->draw_hline)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x1,x2,y);
 }
+
 void Gtk::Style::draw_vline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int y1, int y2, int x) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2129,6 +2011,7 @@ void Gtk::Style::draw_vline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::
   if(base && base->draw_vline)
     (*base->draw_vline)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),y1,y2,x);
 }
+
 void Gtk::Style::draw_shadow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2138,6 +2021,7 @@ void Gtk::Style::draw_shadow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk:
   if(base && base->draw_shadow)
     (*base->draw_shadow)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_polygon_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, GdkPoint* point, int npoints, bool fill) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2147,6 +2031,7 @@ void Gtk::Style::draw_polygon_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk
   if(base && base->draw_polygon)
     (*base->draw_polygon)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),point,npoints,static_cast<int>(fill));
 }
+
 void Gtk::Style::draw_arrow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gtk::ArrowType arrow_type, bool fill, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2156,6 +2041,7 @@ void Gtk::Style::draw_arrow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::
   if(base && base->draw_arrow)
     (*base->draw_arrow)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),((GtkArrowType)(arrow_type)),static_cast<int>(fill),x,y,width,height);
 }
+
 void Gtk::Style::draw_diamond_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2165,6 +2051,7 @@ void Gtk::Style::draw_diamond_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk
   if(base && base->draw_diamond)
     (*base->draw_diamond)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_string_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::ustring& string) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2174,6 +2061,7 @@ void Gtk::Style::draw_string_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk:
   if(base && base->draw_string)
     (*base->draw_string)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,string.c_str());
 }
+
 void Gtk::Style::draw_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2183,6 +2071,7 @@ void Gtk::Style::draw_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::St
   if(base && base->draw_box)
     (*base->draw_box)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_flat_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2192,6 +2081,7 @@ void Gtk::Style::draw_flat_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gt
   if(base && base->draw_flat_box)
     (*base->draw_flat_box)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_check_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2201,6 +2091,7 @@ void Gtk::Style::draw_check_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::
   if(base && base->draw_check)
     (*base->draw_check)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_option_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2210,6 +2101,7 @@ void Gtk::Style::draw_option_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk:
   if(base && base->draw_option)
     (*base->draw_option)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_tab_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2219,6 +2111,7 @@ void Gtk::Style::draw_tab_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::St
   if(base && base->draw_tab)
     (*base->draw_tab)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_shadow_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2228,6 +2121,7 @@ void Gtk::Style::draw_shadow_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window,
   if(base && base->draw_shadow_gap)
     (*base->draw_shadow_gap)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkPositionType)(gap_side)),gap_x,gap_width);
 }
+
 void Gtk::Style::draw_box_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2237,6 +2131,7 @@ void Gtk::Style::draw_box_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk
   if(base && base->draw_box_gap)
     (*base->draw_box_gap)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkPositionType)(gap_side)),gap_x,gap_width);
 }
+
 void Gtk::Style::draw_extension_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2246,6 +2141,7 @@ void Gtk::Style::draw_extension_vfunc(const Glib::RefPtr<Gdk::Window>& window, G
   if(base && base->draw_extension)
     (*base->draw_extension)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkPositionType)(gap_side)));
 }
+
 void Gtk::Style::draw_focus_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2255,6 +2151,7 @@ void Gtk::Style::draw_focus_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::
   if(base && base->draw_focus)
     (*base->draw_focus)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height);
 }
+
 void Gtk::Style::draw_slider_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2264,6 +2161,7 @@ void Gtk::Style::draw_slider_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk:
   if(base && base->draw_slider)
     (*base->draw_slider)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkOrientation)(orientation)));
 }
+
 void Gtk::Style::draw_handle_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2273,6 +2171,7 @@ void Gtk::Style::draw_handle_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk:
   if(base && base->draw_handle)
     (*base->draw_handle)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),((GtkShadowType)(shadow_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,width,height,((GtkOrientation)(orientation)));
 }
+
 void Gtk::Style::draw_expander_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, ExpanderStyle expander_style) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2282,6 +2181,7 @@ void Gtk::Style::draw_expander_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gt
   if(base && base->draw_expander)
     (*base->draw_expander)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,((GtkExpanderStyle)(expander_style)));
 }
+
 void Gtk::Style::draw_layout_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, bool use_text, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::RefPtr<Pango::Layout>& layout) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2291,6 +2191,7 @@ void Gtk::Style::draw_layout_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk:
   if(base && base->draw_layout)
     (*base->draw_layout)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),static_cast<int>(use_text),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),x,y,Glib::unwrap(layout));
 }
+
 void Gtk::Style::draw_resize_grip_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gdk::WindowEdge edge, int x, int y, int width, int height) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -2300,7 +2201,6 @@ void Gtk::Style::draw_resize_grip_vfunc(const Glib::RefPtr<Gdk::Window>& window,
   if(base && base->draw_resize_grip)
     (*base->draw_resize_grip)(gobj(),Glib::unwrap(window),((GtkStateType)(state_type)),const_cast<GdkRectangle*>(area.gobj()),(GtkWidget*)Glib::unwrap(widget),detail.c_str(),((GdkWindowEdge)(edge)),x,y,width,height);
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/style.h b/libs/gtkmm2/gtk/gtkmm/style.h
index ba8059149f..d460abdc61 100644
--- a/libs/gtkmm2/gtk/gtkmm/style.h
+++ b/libs/gtkmm2/gtk/gtkmm/style.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_STYLE_H
 #define _GTKMM_STYLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -134,22 +133,22 @@ public:
   Gdk::Color get_text_aa(Gtk::StateType state) const;
 
 
-   void set_black(const Gdk::Color& value);
-    Gdk::Color get_black() const;
-    void set_white(const Gdk::Color& value);
-    Gdk::Color get_white() const;
- 
+  void set_black(const Gdk::Color& value);
+  Gdk::Color get_black() const;
+  void set_white(const Gdk::Color& value);
+  Gdk::Color get_white() const;
+
   void set_font(const Pango::FontDescription& font_desc);
 
   // These are only available after being attached to a window.
   Pango::FontDescription get_font() const;
 
   void set_xthickness(int xthickness);
-   int get_xthickness() const;
- 
+  int get_xthickness() const;
+
   void set_ythickness(int ythickness);
-   int get_ythickness() const;
- 
+  int get_ythickness() const;
+
   Glib::RefPtr<Gdk::GC> get_fg_gc(Gtk::StateType state_type);
   Glib::RefPtr<const Gdk::GC> get_fg_gc(Gtk::StateType state_type) const;
 
@@ -171,29 +170,23 @@ public:
   Glib::RefPtr<Gdk::GC> get_base_gc(Gtk::StateType state_type);
   Glib::RefPtr<const Gdk::GC> get_base_gc(Gtk::StateType state_type) const;
 
-   Glib::RefPtr<Gdk::GC> get_black_gc();
+  Glib::RefPtr<Gdk::GC> get_black_gc();
   Glib::RefPtr<const Gdk::GC> get_black_gc() const;
-    Glib::RefPtr<Gdk::GC> get_white_gc();
+  Glib::RefPtr<Gdk::GC> get_white_gc();
   Glib::RefPtr<const Gdk::GC> get_white_gc() const;
- 
-  #ifndef GTKMM_DISABLE_DEPRECATED
 
-  /* @deprecated use get_bg() instead.
+  /* Deprecated in gtkmm 2.2 -- use get_bg() instead.
+   * Honestly, I have absolutely no idea why this method was added
+   * in the first place.  It's basically just confusing since it's
+   * absolutely unrelated to set_background().  Sigh.
    */
   Gdk::Color get_background(Gtk::StateType state_type) const;
 
-  /*@deprecated use get_bg() instead.
+  /* Deprecated in gtkmm 2.2 -- use get_bg_pixmap() instead.
    */
   Glib::RefPtr<Gdk::Pixmap> get_background_pixmap(Gtk::StateType state_type);
 
-  /** @deprecated Use set_bg_pixmap(Gtk::StateType state_type, const Glib::RefPtr<const Gdk::Pixmap>& pixmap)
-   */
   void set_bg_pixmap(Gtk::StateType state_type, const Glib::RefPtr<Gdk::Pixmap>& pixmap);
-  #endif // GTKMM_DISABLE_DEPRECATED
-
-
-  void set_bg_pixmap(Gtk::StateType state_type, const Glib::RefPtr<const Gdk::Pixmap>& pixmap);
-
   Glib::RefPtr<Gdk::Pixmap>       get_bg_pixmap(Gtk::StateType state_type);
   Glib::RefPtr<const Gdk::Pixmap> get_bg_pixmap(Gtk::StateType state_type) const;
 
@@ -203,10 +196,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type The type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param arrow_type The type of arrow to draw.
    * @param fill <tt>true</tt> if the arrow tip should be filled.
    * @param x X origin of the rectangle to draw the arrow in.
@@ -233,10 +225,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type The type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the box.
    * @param y Y origin of the box.
    * @param width The width of the box.
@@ -260,10 +251,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type Type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the rectangle.
    * @param y Y origin of the rectangle.
    * @param width Width of the rectangle.
@@ -293,10 +283,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type The type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the rectangle to draw the check in.
    * @param y Y origin of the rectangle to draw the check in.
    * @param width The width of the rectangle to draw the check in.
@@ -320,10 +309,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type The type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the rectangle to draw the diamond in.
    * @param y Y origin of the rectangle to draw the diamond in.
    * @param width Width of the rectangle to draw the diamond in.
@@ -346,10 +334,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type Type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the extension.
    * @param y Y origin of the extension.
    * @param width Width of the extension.
@@ -374,10 +361,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type The type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the box.
    * @param y Y origin of the box.
    * @param width The width of the box.
@@ -400,10 +386,9 @@ public:
    * given style.
    * @param window A Gdk::Window.
    * @param state_type A state.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x The x origin of the rectangle around which to draw a focus indicator.
    * @param y The y origin of the rectangle around which to draw a focus indicator.
    * @param width The width of the rectangle around which to draw a focus indicator.
@@ -425,10 +410,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type Type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the handle.
    * @param y Y origin of the handle.
    * @param width With of the handle.
@@ -453,10 +437,9 @@ public:
    * using the given style and state.
    * @param window A Gdk::Window.
    * @param state_type A state.
-   * @param area Rectangle to which the output is clipped, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Rectangle to which the output is clipped.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x1 The starting x coordinate.
    * @param x2 The ending x coordinate.
    * @param y The y coordinate.
@@ -477,10 +460,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type The type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the rectangle to draw the option in.
    * @param y Y origin of the rectangle to draw the option in.
    * @param width The width of the rectangle to draw the option in.
@@ -514,10 +496,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type Type of shadow to draw.
-   * @param area Clip rectangle or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the rectangle.
    * @param y Y origin of the rectangle.
    * @param width Width of the rectangle.
@@ -542,10 +523,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type Type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the rectangle.
    * @param y Y origin of the rectangle.
    * @param width Width of the rectangle.
@@ -591,10 +571,9 @@ public:
    * @param window A Gdk::Window.
    * @param state_type A state.
    * @param shadow_type The type of shadow to draw.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x X origin of the rectangle to draw the tab in.
    * @param y Y origin of the rectangle to draw the tab in.
    * @param width The width of the rectangle to draw the tab in.
@@ -617,10 +596,9 @@ public:
    * using the given style and state.
    * @param window A Gdk::Window.
    * @param state_type A state.
-   * @param area Rectangle to which the output is clipped, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Rectangle to which the output is clipped.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param y1 The starting y coordinate.
    * @param y2 The ending y coordinate.
    * @param x The x coordinate.
@@ -636,26 +614,15 @@ public:
                   int                               x) const;
 
   
-  /** Draws an expander as used in Gtk::TreeView. @a x  and @a y  specify the
-   * center the expander. The size of the expander is determined by the
-   * "expander-size" style property of @a widget .  (If widget is not
-   * specified or doesn't have an "expander-size" property, an
-   * unspecified default size will be used, since the caller doesn't
-   * have sufficient information to position the expander, this is
-   * likely not useful.) The expander is expander_size pixels tall
-   * in the collapsed position and expander_size pixels wide in the
-   * expanded position.
+  /** Draws an expander as used in Gtk::TreeView.
    * @param window A Gdk::Window.
    * @param state_type A state.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param x The x position to draw the expander at.
    * @param y The y position to draw the expander at.
-   * @param expander_style The style to draw the expander in; determines
-   * whether the expander is collapsed, expanded, or in an
-   * intermediate state.
+   * @param expander_style The style to draw the expander in.
    */
   void paint_expander(
                   const Glib::RefPtr<Gdk::Window>&  window,
@@ -686,10 +653,9 @@ public:
    * parameters.
    * @param window A Gdk::Window.
    * @param state_type A state.
-   * @param area Clip rectangle, or <tt>0</tt> if the
-   * output should not be clipped.
-   * @param widget The widget (may be <tt>0</tt>).
-   * @param detail A style detail (may be <tt>0</tt>).
+   * @param area Clip rectangle.
+   * @param widget The widget.
+   * @param detail A style detail.
    * @param edge The edge in which to draw the resize grip.
    * @param x The x origin of the rectangle in which to draw the resize grip.
    * @param y The y origin of the rectangle in which to draw the resize grip.
@@ -733,9 +699,6 @@ public:
   IconSet lookup_icon_set(const Gtk::StockID& stock_id);
 
   
-  bool lookup_color(const Glib::ustring& color_name, Gdk::Color& color) const;
-
-
   /** Renders the icon specified by @a source  at the given @a size  
    * according to the given parameters and returns the result in a 
    * pixbuf.
@@ -753,133 +716,40 @@ public:
                                        Gtk::Widget& widget, const Glib::ustring& detail);
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void realize_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void unrealize_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void copy_vfunc(const Glib::RefPtr<Style>& src);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Style> clone_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void init_from_rc_vfunc(const Glib::RefPtr<RcStyle>& rc_style);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_background_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual Glib::RefPtr<Gdk::Pixbuf> render_icon_vfunc(const IconSource& source, TextDirection direction, Gtk::StateType state, IconSize size, Widget* widget, const Glib::ustring& detail);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_hline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x1, int x2, int y);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_vline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int y1, int y2, int x);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_shadow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_polygon_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, GdkPoint* point, int npoints, bool fill);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_arrow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gtk::ArrowType arrow_type, bool fill, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_diamond_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_string_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::ustring& string);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_flat_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_check_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_option_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_tab_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_shadow_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_box_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_extension_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_focus_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_slider_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_handle_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_expander_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, ExpanderStyle expander_style);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_layout_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, bool use_text, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::RefPtr<Pango::Layout>& layout);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_resize_grip_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gdk::WindowEdge edge, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-/**
-   * @par Prototype:
-   * <tt>void %realize()</tt>
-   */
+    virtual void realize_vfunc();
+    virtual void unrealize_vfunc();
+    virtual void copy_vfunc(const Glib::RefPtr<Style>& src);
+    virtual Glib::RefPtr<Style> clone_vfunc();
+    virtual void init_from_rc_vfunc(const Glib::RefPtr<RcStyle>& rc_style);
+    virtual void set_background_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type);
+
+    virtual Glib::RefPtr<Gdk::Pixbuf> render_icon_vfunc(const IconSource& source, TextDirection direction, Gtk::StateType state, IconSize size, Widget* widget, const Glib::ustring& detail);
+    virtual void draw_hline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x1, int x2, int y);
+    virtual void draw_vline_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int y1, int y2, int x);
+    virtual void draw_shadow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_polygon_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, GdkPoint* point, int npoints, bool fill);
+    virtual void draw_arrow_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gtk::ArrowType arrow_type, bool fill, int x, int y, int width, int height);
+    virtual void draw_diamond_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_string_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::ustring& string);
+    virtual void draw_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_flat_box_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_check_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_option_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_tab_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_shadow_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width);
+    virtual void draw_box_gap_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Gtk::PositionType gap_side, int gap_x, int gap_width);
+    virtual void draw_extension_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, PositionType gap_side);
+    virtual void draw_focus_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height);
+    virtual void draw_slider_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation);
+    virtual void draw_handle_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, ShadowType shadow_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, int width, int height, Orientation orientation);
+    virtual void draw_expander_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, ExpanderStyle expander_style);
+    virtual void draw_layout_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, bool use_text, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, int x, int y, const Glib::RefPtr<Pango::Layout>& layout);
+    virtual void draw_resize_grip_vfunc(const Glib::RefPtr<Gdk::Window>& window, Gtk::StateType state_type, const Gdk::Rectangle& area, Widget* widget, const Glib::ustring& detail, Gdk::WindowEdge edge, int x, int y, int width, int height);
 
+  
   Glib::SignalProxy0< void > signal_realize();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %unrealize()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_unrealize();
 
 
@@ -887,19 +757,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_realize();
   virtual void on_unrealize();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/table.cc b/libs/gtkmm2/gtk/gtkmm/table.cc
index f92e74413d..7fd5cb8292 100644
--- a/libs/gtkmm2/gtk/gtkmm/table.cc
+++ b/libs/gtkmm2/gtk/gtkmm/table.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/table.h>
 #include <gtkmm/private/table_p.h>
 
@@ -171,19 +170,8 @@ void Table_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Table_Class::wrap_new(GObject* o)
 {
@@ -230,7 +218,7 @@ namespace Table_Helpers
 void TableList::remove(const_reference child)
 {
   gtk_container_remove(GTK_CONTAINER(gparent_),
-                       (GtkWidget*)(child.get_widget ()->gobj()));
+                       (GtkWidget*)(child.gobj()));
 }
 
 void TableList::remove(Widget& widget)
@@ -249,7 +237,7 @@ TableList::iterator TableList::erase(iterator position)
   next++;
 
   //Use GTK+ C function to remove it, by providing the GtkWidget*:
-  gtk_container_remove( GTK_CONTAINER(gparent_), (GtkWidget*)(position->get_widget ()->gobj()) );
+  gtk_container_remove( GTK_CONTAINER(gparent_), (GtkWidget*)(position->gobj()) );
   return next;
 }
 
@@ -313,17 +301,17 @@ Table::Table(guint n_rows, guint n_columns, bool homogeneous)
 
 void Table::attach(Widget& child, guint left_attach, guint right_attach, guint top_attach, guint bottom_attach, AttachOptions xoptions, AttachOptions yoptions, guint xpadding, guint ypadding)
 {
-gtk_table_attach(gobj(), (child).gobj(), left_attach, right_attach, top_attach, bottom_attach, ((GtkAttachOptions)(xoptions)), ((GtkAttachOptions)(yoptions)), xpadding, ypadding); 
+  gtk_table_attach(gobj(), (child).gobj(), left_attach, right_attach, top_attach, bottom_attach, ((GtkAttachOptions)(xoptions)), ((GtkAttachOptions)(yoptions)), xpadding, ypadding);
 }
 
 void Table::resize(guint rows, guint columns)
 {
-gtk_table_resize(gobj(), rows, columns); 
+  gtk_table_resize(gobj(), rows, columns);
 }
 
 void Table::set_row_spacing(guint row, guint spacing)
 {
-gtk_table_set_row_spacing(gobj(), row, spacing); 
+  gtk_table_set_row_spacing(gobj(), row, spacing);
 }
 
 guint Table::get_row_spacing(guint row) const
@@ -333,7 +321,7 @@ guint Table::get_row_spacing(guint row) const
 
 void Table::set_col_spacing(guint column, guint spacing)
 {
-gtk_table_set_col_spacing(gobj(), column, spacing); 
+  gtk_table_set_col_spacing(gobj(), column, spacing);
 }
 
 guint Table::get_col_spacing(guint column) const
@@ -343,12 +331,12 @@ guint Table::get_col_spacing(guint column) const
 
 void Table::set_row_spacings(guint spacing)
 {
-gtk_table_set_row_spacings(gobj(), spacing); 
+  gtk_table_set_row_spacings(gobj(), spacing);
 }
 
 void Table::set_col_spacings(guint spacing)
 {
-gtk_table_set_col_spacings(gobj(), spacing); 
+  gtk_table_set_col_spacings(gobj(), spacing);
 }
 
 guint Table::get_default_row_spacing()
@@ -363,7 +351,7 @@ guint Table::get_default_col_spacing()
 
 void Table::set_homogeneous(bool homogeneous)
 {
-gtk_table_set_homogeneous(gobj(), static_cast<int>(homogeneous)); 
+  gtk_table_set_homogeneous(gobj(), static_cast<int>(homogeneous));
 }
 
 bool Table::get_homogeneous() const
@@ -372,68 +360,45 @@ bool Table::get_homogeneous() const
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Table::property_n_rows() 
 {
   return Glib::PropertyProxy<guint>(this, "n-rows");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Table::property_n_rows() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "n-rows");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Table::property_n_columns() 
 {
   return Glib::PropertyProxy<guint>(this, "n-columns");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Table::property_n_columns() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "n-columns");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Table::property_column_spacing() 
 {
   return Glib::PropertyProxy<guint>(this, "column-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Table::property_column_spacing() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "column-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Table::property_row_spacing() 
 {
   return Glib::PropertyProxy<guint>(this, "row-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Table::property_row_spacing() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "row-spacing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/table.h b/libs/gtkmm2/gtk/gtkmm/table.h
index 73ce84fd3e..5dd6a8987e 100644
--- a/libs/gtkmm2/gtk/gtkmm/table.h
+++ b/libs/gtkmm2/gtk/gtkmm/table.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TABLE_H
 #define _GTKMM_TABLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -210,17 +209,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -286,7 +279,7 @@ public:
   void set_homogeneous(bool homogeneous = true);
   
   /** Returns whether the table cells are all constrained to the same
-   * width and height. (See set_homogenous())
+   * width and height. (See gtk_table_set_homogenous())
    * @return <tt>true</tt> if the cells are all constrained to the same size.
    */
   bool get_homogeneous() const;
@@ -297,17 +290,14 @@ public:
   TableList& children();
   const TableList& children() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of rows in the table.
+  /** The number of rows in the table.
    *
    * 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_n_rows() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The number of rows in the table.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -315,19 +305,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_n_rows() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The number of columns in the table.
+  /** The number of columns in the table.
    *
    * 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_n_columns() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The number of columns in the table.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -335,19 +321,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_n_columns() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The amount of space between two consecutive columns.
+  /** The amount of space between two consecutive columns.
    *
    * 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_column_spacing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The amount of space between two consecutive columns.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -355,19 +337,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_column_spacing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The amount of space between two consecutive rows.
+  /** The amount of space between two consecutive rows.
    *
    * 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_row_spacing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The amount of space between two consecutive rows.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -375,7 +353,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_row_spacing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -397,8 +374,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Table* wrap(GtkTable* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TABLE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/targetlist.cc b/libs/gtkmm2/gtk/gtkmm/targetlist.cc
index 2633080e70..8629b4f1a9 100644
--- a/libs/gtkmm2/gtk/gtkmm/targetlist.cc
+++ b/libs/gtkmm2/gtk/gtkmm/targetlist.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/targetlist.h>
 #include <gtkmm/private/targetlist_p.h>
 
@@ -111,12 +110,12 @@ GtkTargetList* TargetList::gobj_copy() const
 
 void TargetList::add(const Glib::ustring& target, TargetFlags flags, guint info)
 {
-gtk_target_list_add(gobj(), Gdk::AtomString::to_c_type(target), (guint)(flags), info); 
+  gtk_target_list_add(gobj(), Gdk::AtomString::to_c_type(target), (guint)(flags), info);
 }
 
 void TargetList::remove(const Glib::ustring& target)
 {
-gtk_target_list_remove(gobj(), Gdk::AtomString::to_c_type(target)); 
+  gtk_target_list_remove(gobj(), Gdk::AtomString::to_c_type(target));
 }
 
 bool TargetList::find(const Glib::ustring& target, guint* info) const
diff --git a/libs/gtkmm2/gtk/gtkmm/targetlist.h b/libs/gtkmm2/gtk/gtkmm/targetlist.h
index 4c14339fc3..286d533ee1 100644
--- a/libs/gtkmm2/gtk/gtkmm/targetlist.h
+++ b/libs/gtkmm2/gtk/gtkmm/targetlist.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TARGETLIST_H
 #define _GTKMM_TARGETLIST_H
 
-
 #include <glibmm.h>
 
 /* Copyright(C) 2002 The gtkmm Development Team
@@ -69,24 +68,11 @@ public:
   static Glib::RefPtr<Gtk::TargetList> create(const ArrayHandle_TargetEntry& targets);
   
  
-  /** Appends another target to a Gtk::TargetList.
-   * @param target The interned atom representing the target.
-   * @param flags The flags for this target.
-   * @param info An ID that will be passed back to the application.
-   */
   void add(const Glib::ustring& target, TargetFlags flags = TargetFlags(0), guint info = 0);
   void add(const ArrayHandle_TargetEntry& targets);
   
-  /** Removes a target from a target list.
-   * @param target The interned atom representing the target.
-   */
   void remove(const Glib::ustring& target);
   
-  /** Looks up a given target in a Gtk::TargetList.
-   * @param target An interned atom representing the target to search for.
-   * @param info A pointer to the location to store application info for target.
-   * @return <tt>true</tt> if the target was found, otherwise <tt>false</tt>.
-   */
   bool find(const Glib::ustring& target, guint* info) const;
 
 
@@ -107,6 +93,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TARGETLIST_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.cc b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.cc
index 920c9a9d28..fbcc26f2cd 100644
--- a/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/tearoffmenuitem.h>
 #include <gtkmm/private/tearoffmenuitem_p.h>
 
@@ -37,6 +36,7 @@ bool TearoffMenuItem::is_torn_off() const
 }
 
 } /* namespace Gtk */
+
 namespace
 {
 } // anonymous namespace
@@ -83,19 +83,8 @@ void TearoffMenuItem_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* TearoffMenuItem_Class::wrap_new(GObject* o)
 {
@@ -144,13 +133,6 @@ TearoffMenuItem::TearoffMenuItem()
   }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.h b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.h
index 9033151bcc..f2c619c0ee 100644
--- a/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/tearoffmenuitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEAROFFMENUITEM_H
 #define _GTKMM_TEAROFFMENUITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -92,17 +91,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -126,8 +119,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::TearoffMenuItem* wrap(GtkTearoffMenuItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TEAROFFMENUITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/textattributes.cc b/libs/gtkmm2/gtk/gtkmm/textattributes.cc
index 1e4c7b469d..ff1e647a08 100644
--- a/libs/gtkmm2/gtk/gtkmm/textattributes.cc
+++ b/libs/gtkmm2/gtk/gtkmm/textattributes.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/textattributes.h>
 #include <gtkmm/private/textattributes_p.h>
 
diff --git a/libs/gtkmm2/gtk/gtkmm/textattributes.h b/libs/gtkmm2/gtk/gtkmm/textattributes.h
index 960be8b300..6deef34cab 100644
--- a/libs/gtkmm2/gtk/gtkmm/textattributes.h
+++ b/libs/gtkmm2/gtk/gtkmm/textattributes.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTATTRIBUTES_H
 #define _GTKMM_TEXTATTRIBUTES_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -111,6 +110,5 @@ class Value<Gtk::TextAttributes> : public Glib::Value_Boxed<Gtk::TextAttributes>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TEXTATTRIBUTES_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/textbuffer.cc b/libs/gtkmm2/gtk/gtkmm/textbuffer.cc
index a0ae07616c..ab66089ba8 100644
--- a/libs/gtkmm2/gtk/gtkmm/textbuffer.cc
+++ b/libs/gtkmm2/gtk/gtkmm/textbuffer.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/textbuffer.h>
 #include <gtkmm/private/textbuffer_p.h>
 
@@ -25,73 +24,11 @@
  */
 
 #include <gtk/gtktextbuffer.h>
-#include <gtk/gtktextbufferrichtext.h>
 #include <glib/gslist.h>
 #include <gtkmm/textmark.h>
 #include <gtkmm/textiter.h>
 
 
-/*
-static guint8* SignalProxy_Serialize(GtkTextBuffer* , GtkTextBuffer* content_buffer,
-                                                   const GtkTextIter* start, const GtkTextIter* end,
-                                                   gsize* length,
-                                                   gpointer user_data)
-{
-  Gtk::TextBuffer::SlotSerialize* the_slot = static_cast<Gtk::TextBuffer::SlotSerialize*>(user_data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    return (*the_slot)(Glib::wrap(content_buffer), Glib::wrap(start), Glib::wrap(end), *length);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-
-  return 0; // arbitrary value
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_Serialize_gtk_callback_destroy(void* user_data)
-{
-  delete static_cast<Gtk::TextBuffer::SlotSerialize*>(user_data);
-}
-
-static gboolean SignalProxy_Deserialize(GtkTextBuffer* , GtkTextBuffer* content_buffer,
-                                                   GtkTextIter* iter, const guint8* data,
-                                                   gsize length, gboolean create_tags,
-                                                   gpointer user_data,
-                                                   GError** )
-{
-  Gtk::TextBuffer::SlotDeserialize* the_slot = static_cast<Gtk::TextBuffer::SlotDeserialize*>(user_data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    (*the_slot)(Glib::wrap(content_buffer, true), Glib::wrap(iter), data, length, create_tags);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    //TODO: Fill the error parameter.
-    Glib::exception_handlers_invoke();
-  }
-
-  return 0; // arbitrary value
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_Deserialize_gtk_callback_destroy(void* user_data)
-{
-  delete static_cast<Gtk::TextBuffer::SlotDeserialize*>(user_data);
-}
-*/
-
 namespace Gtk
 {
 
@@ -191,19 +128,17 @@ void TextBuffer::set_text(const char* text_begin, const char* text_end)
   gtk_text_buffer_set_text(gobj(), text_begin, text_end - text_begin);
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+//deprecated:
 void TextBuffer::assign(const Glib::ustring& text)
 {
   gtk_text_buffer_set_text(gobj(), text.data(), text.bytes());
 }
 
+//deprecated:
 void TextBuffer::assign(const char* text_begin, const char* text_end)
 {
   gtk_text_buffer_set_text(gobj(), text_begin, text_end - text_begin);
 }
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
 TextBuffer::iterator TextBuffer::insert(const iterator& pos, const Glib::ustring& text)
 {
@@ -518,100 +453,18 @@ int TextBuffer::size() const
   return get_char_count();
 }
 
-//This is not public API:
-//(and it is copy/pasted from clipboard.ccg)
-typedef std::list<Glib::ustring> listStrings;
-static listStrings util_convert_atoms_to_strings(GdkAtom* targets, int n_targets)
-{
-  listStrings listTargets;
-
-  //Add the targets to the C++ container:
-  for(int i = 0; i < n_targets; i++)
-  {
-    //Convert the atom to a string:
-    char* atom_name = gdk_atom_name(targets[i]);
-    if(atom_name)
-    {
-      listTargets.push_back( Glib::ustring(atom_name) );
-      g_free(atom_name);
-    }
-  }
-
-  return listTargets;
-}
-
 Glib::ustring TextBuffer::get_text(bool include_hidden_chars)
 {
   return get_text(begin(), end(), include_hidden_chars);
 }
 
-Glib::StringArrayHandle TextBuffer::get_serialize_formats() const
-{
-  int n_atoms = 0;
-  GdkAtom* atoms = gtk_text_buffer_get_serialize_formats(const_cast<GtkTextBuffer*>(gobj()), &n_atoms);
-  return util_convert_atoms_to_strings(atoms, n_atoms);
-}
-
-Glib::StringArrayHandle TextBuffer::get_deserialize_formats() const
-{
-  int n_atoms = 0;
-  GdkAtom* atoms = gtk_text_buffer_get_deserialize_formats(const_cast<GtkTextBuffer*>(gobj()), &n_atoms);
-  return util_convert_atoms_to_strings(atoms, n_atoms);
-}
-
-/*
-Glib::ustring TextBuffer::register_serialize_format(const Glib::ustring& mime_type, const SlotSerialize& slot)
-{
-  SlotSerialize* slot_copy = new SlotSerialize(slot);
-  GdkAtom atom = gtk_text_buffer_register_serialize_format(gobj(), mime_type.c_str(), 
-                &SignalProxy_Serialize, slot_copy, &SignalProxy_Serialize_gtk_callback_destroy);
-
-  //Convert the atom to a string:
-  Glib::ustring atom_as_string;
-  char* atom_name = gdk_atom_name(atom);
-  if(atom_name)
-  {
-    atom_as_string = atom_name;
-    g_free(atom_name);
-  }
-
-  return atom_as_string;
-}
-
-Glib::ustring TextBuffer::register_deserialize_format(const Glib::ustring& mime_type, const SlotDeserialize& slot)
-{
-  SlotDeserialize* slot_copy = new SlotDeserialize(slot);
-  GdkAtom atom = gtk_text_buffer_register_deserialize_format(gobj(), mime_type.c_str(), 
-                &SignalProxy_Deserialize, slot_copy, &SignalProxy_Deserialize_gtk_callback_destroy);
-
-  //Convert the atom to a string:
-  Glib::ustring atom_as_string;
-  char* atom_name = gdk_atom_name(atom);
-  if(atom_name)
-  {
-    atom_as_string = atom_name;
-    g_free(atom_name);
-  }
-
-  return atom_as_string;
-}
-*/
-
-#ifdef GTKMM_MAEMO_EXTENSIONS_ENABLED
-void TextBuffer::set_rich_text_format_all()
-{
-  gtk_text_buffer_set_rich_text_format(gobj(), NULL);
-}
-#endif //GTKMM_MAEMO_EXTENSIONS_ENABLED
-
 } // namespace Gtk
 
 
 namespace
 {
 
-
-static void TextBuffer_signal_insert_callback(GtkTextBuffer* self, GtkTextIter* p0,const gchar* p1,gint p2,void* data)
+void TextBuffer_signal_insert_callback(GtkTextBuffer* self, GtkTextIter* p0,const gchar* p1,gint p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::ustring&,int > SlotType;
@@ -619,26 +472,22 @@ static void TextBuffer_signal_insert_callback(GtkTextBuffer* self, GtkTextIter*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::ustring(p1, p1 + p2)
 , p2
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_insert_info =
+const Glib::SignalProxyInfo TextBuffer_signal_insert_info =
 {
   "insert_text",
   (GCallback) &TextBuffer_signal_insert_callback,
@@ -646,7 +495,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_insert_info =
 };
 
 
-static void TextBuffer_signal_insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter* p0,GdkPixbuf* p1,void* data)
+void TextBuffer_signal_insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter* p0,GdkPixbuf* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& > SlotType;
@@ -654,25 +503,21 @@ static void TextBuffer_signal_insert_pixbuf_callback(GtkTextBuffer* self, GtkTex
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_insert_pixbuf_info =
+const Glib::SignalProxyInfo TextBuffer_signal_insert_pixbuf_info =
 {
   "insert_pixbuf",
   (GCallback) &TextBuffer_signal_insert_pixbuf_callback,
@@ -680,7 +525,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_insert_pixbuf_info =
 };
 
 
-static void TextBuffer_signal_insert_child_anchor_callback(GtkTextBuffer* self, GtkTextIter* p0,GtkTextChildAnchor* p1,void* data)
+void TextBuffer_signal_insert_child_anchor_callback(GtkTextBuffer* self, GtkTextIter* p0,GtkTextChildAnchor* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& > SlotType;
@@ -688,25 +533,21 @@ static void TextBuffer_signal_insert_child_anchor_callback(GtkTextBuffer* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_insert_child_anchor_info =
+const Glib::SignalProxyInfo TextBuffer_signal_insert_child_anchor_info =
 {
   "insert_child_anchor",
   (GCallback) &TextBuffer_signal_insert_child_anchor_callback,
@@ -714,7 +555,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_insert_child_anchor_info =
 };
 
 
-static void TextBuffer_signal_erase_callback(GtkTextBuffer* self, GtkTextIter* p0,GtkTextIter* p1,void* data)
+void TextBuffer_signal_erase_callback(GtkTextBuffer* self, GtkTextIter* p0,GtkTextIter* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TextBuffer::iterator&,const TextBuffer::iterator& > SlotType;
@@ -722,25 +563,21 @@ static void TextBuffer_signal_erase_callback(GtkTextBuffer* self, GtkTextIter* p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_erase_info =
+const Glib::SignalProxyInfo TextBuffer_signal_erase_info =
 {
   "delete_range",
   (GCallback) &TextBuffer_signal_erase_callback,
@@ -748,7 +585,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_erase_info =
 };
 
 
-static const Glib::SignalProxyInfo TextBuffer_signal_changed_info =
+const Glib::SignalProxyInfo TextBuffer_signal_changed_info =
 {
   "changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -756,7 +593,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_changed_info =
 };
 
 
-static const Glib::SignalProxyInfo TextBuffer_signal_modified_changed_info =
+const Glib::SignalProxyInfo TextBuffer_signal_modified_changed_info =
 {
   "modified_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -764,7 +601,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_modified_changed_info =
 };
 
 
-static void TextBuffer_signal_mark_set_callback(GtkTextBuffer* self, const GtkTextIter* p0,GtkTextMark* p1,void* data)
+void TextBuffer_signal_mark_set_callback(GtkTextBuffer* self, const GtkTextIter* p0,GtkTextMark* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& > SlotType;
@@ -772,25 +609,21 @@ static void TextBuffer_signal_mark_set_callback(GtkTextBuffer* self, const GtkTe
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_mark_set_info =
+const Glib::SignalProxyInfo TextBuffer_signal_mark_set_info =
 {
   "mark_set",
   (GCallback) &TextBuffer_signal_mark_set_callback,
@@ -798,7 +631,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_mark_set_info =
 };
 
 
-static void TextBuffer_signal_mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p0,void* data)
+void TextBuffer_signal_mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<TextBuffer::Mark>& > SlotType;
@@ -806,24 +639,20 @@ static void TextBuffer_signal_mark_deleted_callback(GtkTextBuffer* self, GtkText
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_mark_deleted_info =
+const Glib::SignalProxyInfo TextBuffer_signal_mark_deleted_info =
 {
   "mark_deleted",
   (GCallback) &TextBuffer_signal_mark_deleted_callback,
@@ -831,7 +660,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_mark_deleted_info =
 };
 
 
-static void TextBuffer_signal_apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,const GtkTextIter* p1,const GtkTextIter* p2,void* data)
+void TextBuffer_signal_apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,const GtkTextIter* p1,const GtkTextIter* p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > SlotType;
@@ -839,26 +668,22 @@ static void TextBuffer_signal_apply_tag_callback(GtkTextBuffer* self, GtkTextTag
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 , Glib::wrap(p2)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_apply_tag_info =
+const Glib::SignalProxyInfo TextBuffer_signal_apply_tag_info =
 {
   "apply_tag",
   (GCallback) &TextBuffer_signal_apply_tag_callback,
@@ -866,7 +691,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_apply_tag_info =
 };
 
 
-static void TextBuffer_signal_remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,const GtkTextIter* p1,const GtkTextIter* p2,void* data)
+void TextBuffer_signal_remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,const GtkTextIter* p1,const GtkTextIter* p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > SlotType;
@@ -874,26 +699,22 @@ static void TextBuffer_signal_remove_tag_callback(GtkTextBuffer* self, GtkTextTa
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 , Glib::wrap(p2)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextBuffer_signal_remove_tag_info =
+const Glib::SignalProxyInfo TextBuffer_signal_remove_tag_info =
 {
   "remove_tag",
   (GCallback) &TextBuffer_signal_remove_tag_callback,
@@ -901,7 +722,7 @@ static const Glib::SignalProxyInfo TextBuffer_signal_remove_tag_info =
 };
 
 
-static const Glib::SignalProxyInfo TextBuffer_signal_begin_user_action_info =
+const Glib::SignalProxyInfo TextBuffer_signal_begin_user_action_info =
 {
   "begin_user_action",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -909,14 +730,13 @@ static const Glib::SignalProxyInfo TextBuffer_signal_begin_user_action_info =
 };
 
 
-static const Glib::SignalProxyInfo TextBuffer_signal_end_user_action_info =
+const Glib::SignalProxyInfo TextBuffer_signal_end_user_action_info =
 {
   "end_user_action",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -963,10 +783,6 @@ void TextBuffer_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->insert_text = &insert_text_callback;
   klass->insert_pixbuf = &insert_pixbuf_callback;
   klass->insert_child_anchor = &insert_child_anchor_callback;
@@ -979,13 +795,9 @@ void TextBuffer_Class::class_init_function(void* g_class, void* class_data)
   klass->remove_tag = &remove_tag_callback;
   klass->begin_user_action = &begin_user_action_callback;
   klass->end_user_action = &end_user_action_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void TextBuffer_Class::insert_text_callback(GtkTextBuffer* self, GtkTextIter* p0, const gchar* p1, gint p2)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -998,22 +810,18 @@ void TextBuffer_Class::insert_text_callback(GtkTextBuffer* self, GtkTextIter* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_insert(Glib::wrap(p0)
 , Glib::ustring(p1, p1 + p2)
 , p2
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1026,6 +834,7 @@ void TextBuffer_Class::insert_text_callback(GtkTextBuffer* self, GtkTextIter* p0
       (*base->insert_text)(self, p0, p1, p2);
   }
 }
+
 void TextBuffer_Class::insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter* p0, GdkPixbuf* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1038,21 +847,17 @@ void TextBuffer_Class::insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_insert_pixbuf(Glib::wrap(p0)
 , Glib::wrap(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1065,6 +870,7 @@ void TextBuffer_Class::insert_pixbuf_callback(GtkTextBuffer* self, GtkTextIter*
       (*base->insert_pixbuf)(self, p0, p1);
   }
 }
+
 void TextBuffer_Class::insert_child_anchor_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextChildAnchor* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1077,21 +883,17 @@ void TextBuffer_Class::insert_child_anchor_callback(GtkTextBuffer* self, GtkText
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_insert_child_anchor(Glib::wrap(p0)
 , Glib::wrap(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1104,6 +906,7 @@ void TextBuffer_Class::insert_child_anchor_callback(GtkTextBuffer* self, GtkText
       (*base->insert_child_anchor)(self, p0, p1);
   }
 }
+
 void TextBuffer_Class::delete_range_callback(GtkTextBuffer* self, GtkTextIter* p0, GtkTextIter* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1116,21 +919,17 @@ void TextBuffer_Class::delete_range_callback(GtkTextBuffer* self, GtkTextIter* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_erase(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1143,6 +942,7 @@ void TextBuffer_Class::delete_range_callback(GtkTextBuffer* self, GtkTextIter* p
       (*base->delete_range)(self, p0, p1);
   }
 }
+
 void TextBuffer_Class::changed_callback(GtkTextBuffer* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1155,19 +955,15 @@ void TextBuffer_Class::changed_callback(GtkTextBuffer* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1180,6 +976,7 @@ void TextBuffer_Class::changed_callback(GtkTextBuffer* self)
       (*base->changed)(self);
   }
 }
+
 void TextBuffer_Class::modified_changed_callback(GtkTextBuffer* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1192,19 +989,15 @@ void TextBuffer_Class::modified_changed_callback(GtkTextBuffer* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_modified_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1217,6 +1010,7 @@ void TextBuffer_Class::modified_changed_callback(GtkTextBuffer* self)
       (*base->modified_changed)(self);
   }
 }
+
 void TextBuffer_Class::mark_set_callback(GtkTextBuffer* self, const GtkTextIter* p0, GtkTextMark* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1229,21 +1023,17 @@ void TextBuffer_Class::mark_set_callback(GtkTextBuffer* self, const GtkTextIter*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_mark_set(Glib::wrap(p0)
 , Glib::wrap(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1256,6 +1046,7 @@ void TextBuffer_Class::mark_set_callback(GtkTextBuffer* self, const GtkTextIter*
       (*base->mark_set)(self, p0, p1);
   }
 }
+
 void TextBuffer_Class::mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1268,20 +1059,16 @@ void TextBuffer_Class::mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_mark_deleted(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1294,6 +1081,7 @@ void TextBuffer_Class::mark_deleted_callback(GtkTextBuffer* self, GtkTextMark* p
       (*base->mark_deleted)(self, p0);
   }
 }
+
 void TextBuffer_Class::apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1306,22 +1094,18 @@ void TextBuffer_Class::apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, c
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_apply_tag(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 , Glib::wrap(p2)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1334,6 +1118,7 @@ void TextBuffer_Class::apply_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, c
       (*base->apply_tag)(self, p0, p1, p2);
   }
 }
+
 void TextBuffer_Class::remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0, const GtkTextIter* p1, const GtkTextIter* p2)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1346,22 +1131,18 @@ void TextBuffer_Class::remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_remove_tag(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 , Glib::wrap(p2)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1374,6 +1155,7 @@ void TextBuffer_Class::remove_tag_callback(GtkTextBuffer* self, GtkTextTag* p0,
       (*base->remove_tag)(self, p0, p1, p2);
   }
 }
+
 void TextBuffer_Class::begin_user_action_callback(GtkTextBuffer* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1386,19 +1168,15 @@ void TextBuffer_Class::begin_user_action_callback(GtkTextBuffer* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_begin_user_action();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1411,6 +1189,7 @@ void TextBuffer_Class::begin_user_action_callback(GtkTextBuffer* self)
       (*base->begin_user_action)(self);
   }
 }
+
 void TextBuffer_Class::end_user_action_callback(GtkTextBuffer* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1423,19 +1202,15 @@ void TextBuffer_Class::end_user_action_callback(GtkTextBuffer* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_end_user_action();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1448,7 +1223,6 @@ void TextBuffer_Class::end_user_action_callback(GtkTextBuffer* self)
       (*base->end_user_action)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TextBuffer_Class::wrap_new(GObject* object)
@@ -1521,15 +1295,20 @@ Glib::RefPtr<TextBuffer::TagTable> TextBuffer::get_tag_table()
 {
 
   Glib::RefPtr<TextBuffer::TagTable> retvalue = Glib::wrap(gtk_text_buffer_get_tag_table(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TextBuffer::TagTable> TextBuffer::get_tag_table() const
 {
-  return const_cast<TextBuffer*>(this)->get_tag_table();
+
+  Glib::RefPtr<const TextBuffer::TagTable> retvalue = Glib::wrap(gtk_text_buffer_get_tag_table(const_cast<GtkTextBuffer*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::ustring TextBuffer::get_text(const iterator& start, const iterator& end, bool include_hidden_chars)
@@ -1537,114 +1316,109 @@ Glib::ustring TextBuffer::get_text(const iterator& start, const iterator& end, b
   return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_buffer_get_text(gobj(), (start).gobj(), (end).gobj(), static_cast<int>(include_hidden_chars)));
 }
 
-Glib::ustring TextBuffer::get_text(const iterator& start, const iterator& end, bool include_hidden_chars) const
-{
-  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_buffer_get_text(const_cast<GtkTextBuffer*>(gobj()), (start).gobj(), (end).gobj(), static_cast<int>(include_hidden_chars)));
-}
-
 Glib::ustring TextBuffer::get_slice(const iterator& start, const iterator& end, bool include_hidden_chars)
 {
   return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_buffer_get_slice(gobj(), (start).gobj(), (end).gobj(), static_cast<int>(include_hidden_chars)));
 }
 
-Glib::ustring TextBuffer::get_slice(const iterator& start, const iterator& end, bool include_hidden_chars) const
-{
-  return Glib::convert_return_gchar_ptr_to_ustring(gtk_text_buffer_get_slice(const_cast<GtkTextBuffer*>(gobj()), (start).gobj(), (end).gobj(), static_cast<int>(include_hidden_chars)));
-}
-
 Glib::RefPtr<TextBuffer::Mark> TextBuffer::create_mark(const Glib::ustring& mark_name, const iterator& where, bool left_gravity)
 {
 
   Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_create_mark(gobj(), mark_name.c_str(), (where).gobj(), static_cast<int>(left_gravity)));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 void TextBuffer::move_mark(const Glib::RefPtr<Mark>& mark, const iterator& where)
 {
-gtk_text_buffer_move_mark(gobj(), Glib::unwrap(mark), (where).gobj()); 
+  gtk_text_buffer_move_mark(gobj(), Glib::unwrap(mark), (where).gobj());
 }
 
 void TextBuffer::delete_mark(const Glib::RefPtr<Mark>& mark)
 {
-gtk_text_buffer_delete_mark(gobj(), Glib::unwrap(mark)); 
+  gtk_text_buffer_delete_mark(gobj(), Glib::unwrap(mark));
 }
 
 Glib::RefPtr<TextBuffer::Mark> TextBuffer::get_mark(const Glib::ustring& name)
 {
 
   Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_mark(gobj(), name.c_str()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TextBuffer::Mark> TextBuffer::get_mark(const Glib::ustring& name) const
 {
-  return const_cast<TextBuffer*>(this)->get_mark(name);
+
+  Glib::RefPtr<const TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_mark(const_cast<GtkTextBuffer*>(gobj()), name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void TextBuffer::move_mark_by_name(const Glib::ustring& name, const iterator& where)
 {
-gtk_text_buffer_move_mark_by_name(gobj(), name.c_str(), (where).gobj()); 
+  gtk_text_buffer_move_mark_by_name(gobj(), name.c_str(), (where).gobj());
 }
 
 void TextBuffer::delete_mark_by_name(const Glib::ustring& name)
 {
-gtk_text_buffer_delete_mark_by_name(gobj(), name.c_str()); 
+  gtk_text_buffer_delete_mark_by_name(gobj(), name.c_str());
 }
 
 Glib::RefPtr<TextBuffer::Mark> TextBuffer::get_insert()
 {
 
   Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_insert(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<TextBuffer::Mark> TextBuffer::get_selection_bound()
 {
 
   Glib::RefPtr<TextBuffer::Mark> retvalue = Glib::wrap(gtk_text_buffer_get_selection_bound(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 void TextBuffer::place_cursor(const iterator& where)
 {
-gtk_text_buffer_place_cursor(gobj(), (where).gobj()); 
+  gtk_text_buffer_place_cursor(gobj(), (where).gobj());
 }
 
 void TextBuffer::apply_tag(const Glib::RefPtr<Tag>& tag, const iterator& start, const iterator& end)
 {
-gtk_text_buffer_apply_tag(gobj(), Glib::unwrap(tag), (start).gobj(), (end).gobj()); 
+  gtk_text_buffer_apply_tag(gobj(), Glib::unwrap(tag), (start).gobj(), (end).gobj());
 }
 
 void TextBuffer::remove_tag(const Glib::RefPtr<Tag>& tag, const iterator& start, const iterator& end)
 {
-gtk_text_buffer_remove_tag(gobj(), Glib::unwrap(tag), (start).gobj(), (end).gobj()); 
+  gtk_text_buffer_remove_tag(gobj(), Glib::unwrap(tag), (start).gobj(), (end).gobj());
 }
 
 void TextBuffer::apply_tag_by_name(const Glib::ustring& name, const iterator& start, const iterator& end)
 {
-gtk_text_buffer_apply_tag_by_name(gobj(), name.c_str(), (start).gobj(), (end).gobj()); 
+  gtk_text_buffer_apply_tag_by_name(gobj(), name.c_str(), (start).gobj(), (end).gobj());
 }
 
 void TextBuffer::remove_tag_by_name(const Glib::ustring& name, const iterator& start, const iterator& end)
 {
-gtk_text_buffer_remove_tag_by_name(gobj(), name.c_str(), (start).gobj(), (end).gobj()); 
+  gtk_text_buffer_remove_tag_by_name(gobj(), name.c_str(), (start).gobj(), (end).gobj());
 }
 
 void TextBuffer::remove_all_tags(const iterator& start, const iterator& end)
 {
-gtk_text_buffer_remove_all_tags(gobj(), (start).gobj(), (end).gobj()); 
+  gtk_text_buffer_remove_all_tags(gobj(), (start).gobj(), (end).gobj());
 }
 
 bool TextBuffer::get_modified() const
@@ -1654,32 +1428,27 @@ bool TextBuffer::get_modified() const
 
 void TextBuffer::set_modified(bool setting)
 {
-gtk_text_buffer_set_modified(gobj(), static_cast<int>(setting)); 
-}
-
-bool TextBuffer::get_has_selection() const
-{
-  return gtk_text_buffer_get_has_selection(const_cast<GtkTextBuffer*>(gobj()));
+  gtk_text_buffer_set_modified(gobj(), static_cast<int>(setting));
 }
 
 void TextBuffer::add_selection_clipboard(const Glib::RefPtr<Clipboard>& clipboard)
 {
-gtk_text_buffer_add_selection_clipboard(gobj(), Glib::unwrap(clipboard)); 
+  gtk_text_buffer_add_selection_clipboard(gobj(), Glib::unwrap(clipboard));
 }
 
 void TextBuffer::remove_selection_clipboard(const Glib::RefPtr<Clipboard>& clipboard)
 {
-gtk_text_buffer_remove_selection_clipboard(gobj(), Glib::unwrap(clipboard)); 
+  gtk_text_buffer_remove_selection_clipboard(gobj(), Glib::unwrap(clipboard));
 }
 
 void TextBuffer::cut_clipboard(const Glib::RefPtr<Clipboard>& clipboard, bool default_editable)
 {
-gtk_text_buffer_cut_clipboard(gobj(), Glib::unwrap(clipboard), static_cast<int>(default_editable)); 
+  gtk_text_buffer_cut_clipboard(gobj(), Glib::unwrap(clipboard), static_cast<int>(default_editable));
 }
 
 void TextBuffer::copy_clipboard(const Glib::RefPtr<Clipboard>& clipboard)
 {
-gtk_text_buffer_copy_clipboard(gobj(), Glib::unwrap(clipboard)); 
+  gtk_text_buffer_copy_clipboard(gobj(), Glib::unwrap(clipboard));
 }
 
 bool TextBuffer::get_selection_bounds(iterator& start, iterator& end) const
@@ -1694,79 +1463,17 @@ bool TextBuffer::erase_selection(bool interactive, bool default_editable)
 
 void TextBuffer::select_range(const iterator& ins, const iterator& bound)
 {
-gtk_text_buffer_select_range(gobj(), (ins).gobj(), (bound).gobj()); 
+  gtk_text_buffer_select_range(gobj(), (ins).gobj(), (bound).gobj());
 }
 
 void TextBuffer::begin_user_action()
 {
-gtk_text_buffer_begin_user_action(gobj()); 
+  gtk_text_buffer_begin_user_action(gobj());
 }
 
 void TextBuffer::end_user_action()
 {
-gtk_text_buffer_end_user_action(gobj()); 
-}
-
-#ifdef GTKMM_MAEMO_EXTENSIONS_ENABLED
-void TextBuffer::set_can_paste_rich_text(bool can_paste_rich_text)
-{
-gtk_text_buffer_set_can_paste_rich_text(gobj(), static_cast<int>(can_paste_rich_text)); 
-}
-
-
-#endif // GTKMM_MAEMO_EXTENSIONS_ENABLED
-#ifdef GTKMM_MAEMO_EXTENSIONS_ENABLED
-bool TextBuffer::get_can_paste_rich_text() const
-{
-  return gtk_text_buffer_get_can_paste_rich_text(const_cast<GtkTextBuffer*>(gobj()));
-}
-
-
-#endif // GTKMM_MAEMO_EXTENSIONS_ENABLED
-#ifdef GTKMM_MAEMO_EXTENSIONS_ENABLED
-void TextBuffer::set_rich_text_format(const Glib::ustring& format)
-{
-gtk_text_buffer_set_rich_text_format(gobj(), format.c_str()); 
-}
-
-
-#endif // GTKMM_MAEMO_EXTENSIONS_ENABLED
-#ifdef GTKMM_MAEMO_EXTENSIONS_ENABLED
-Glib::ustring TextBuffer::get_rich_text_format() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_text_buffer_get_rich_text_format(const_cast<GtkTextBuffer*>(gobj())));
-}
-
-
-#endif // GTKMM_MAEMO_EXTENSIONS_ENABLED
-Glib::ustring TextBuffer::register_serialize_tagset(const Glib::ustring& tagset_name)
-{
-  return Gdk::AtomString::to_cpp_type(gtk_text_buffer_register_serialize_tagset(gobj(), tagset_name.c_str()));
-}
-
-Glib::ustring TextBuffer::register_deserialize_tagset(const Glib::ustring& tagset_name)
-{
-  return Gdk::AtomString::to_cpp_type(gtk_text_buffer_register_deserialize_tagset(gobj(), tagset_name.c_str()));
-}
-
-void TextBuffer::unregister_serialize_format(const Glib::ustring& format)
-{
-gtk_text_buffer_unregister_serialize_format(gobj(), Gdk::AtomString::to_c_type(format)); 
-}
-
-void TextBuffer::unregister_deserialize_format(const Glib::ustring& format)
-{
-gtk_text_buffer_unregister_deserialize_format(gobj(), Gdk::AtomString::to_c_type(format)); 
-}
-
-void TextBuffer::set_can_create_tags(const Glib::ustring& format, bool can_create_tags)
-{
-gtk_text_buffer_deserialize_set_can_create_tags(gobj(), Gdk::AtomString::to_c_type(format), static_cast<int>(can_create_tags)); 
-}
-
-bool TextBuffer::get_can_create_tags(const Glib::ustring& format) const
-{
-  return gtk_text_buffer_deserialize_get_can_create_tags(const_cast<GtkTextBuffer*>(gobj()), Gdk::AtomString::to_c_type(format));
+  gtk_text_buffer_end_user_action(gobj());
 }
 
 
@@ -1775,96 +1482,62 @@ Glib::SignalProxy3< void,const TextBuffer::iterator&,const Glib::ustring&,int >
   return Glib::SignalProxy3< void,const TextBuffer::iterator&,const Glib::ustring&,int >(this, &TextBuffer_signal_insert_info);
 }
 
-
 Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& > TextBuffer::signal_insert_pixbuf()
 {
   return Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& >(this, &TextBuffer_signal_insert_pixbuf_info);
 }
 
-
 Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& > TextBuffer::signal_insert_child_anchor()
 {
   return Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& >(this, &TextBuffer_signal_insert_child_anchor_info);
 }
 
-
 Glib::SignalProxy2< void,const TextBuffer::iterator&,const TextBuffer::iterator& > TextBuffer::signal_erase()
 {
   return Glib::SignalProxy2< void,const TextBuffer::iterator&,const TextBuffer::iterator& >(this, &TextBuffer_signal_erase_info);
 }
 
-
 Glib::SignalProxy0< void > TextBuffer::signal_changed()
 {
   return Glib::SignalProxy0< void >(this, &TextBuffer_signal_changed_info);
 }
 
-
 Glib::SignalProxy0< void > TextBuffer::signal_modified_changed()
 {
   return Glib::SignalProxy0< void >(this, &TextBuffer_signal_modified_changed_info);
 }
 
-
 Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& > TextBuffer::signal_mark_set()
 {
   return Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& >(this, &TextBuffer_signal_mark_set_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<TextBuffer::Mark>& > TextBuffer::signal_mark_deleted()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<TextBuffer::Mark>& >(this, &TextBuffer_signal_mark_deleted_info);
 }
 
-
 Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > TextBuffer::signal_apply_tag()
 {
   return Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& >(this, &TextBuffer_signal_apply_tag_info);
 }
 
-
 Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > TextBuffer::signal_remove_tag()
 {
   return Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& >(this, &TextBuffer_signal_remove_tag_info);
 }
 
-
 Glib::SignalProxy0< void > TextBuffer::signal_begin_user_action()
 {
   return Glib::SignalProxy0< void >(this, &TextBuffer_signal_begin_user_action_info);
 }
 
-
 Glib::SignalProxy0< void > TextBuffer::signal_end_user_action()
 {
   return Glib::SignalProxy0< void >(this, &TextBuffer_signal_end_user_action_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<Glib::ustring> TextBuffer::property_text() 
-{
-  return Glib::PropertyProxy<Glib::ustring>(this, "text");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<Glib::ustring> TextBuffer::property_text() const
-{
-  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> TextBuffer::property_has_selection() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "has-selection");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TextBuffer::on_insert(const TextBuffer::iterator& pos, const Glib::ustring& text, int bytes)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1874,6 +1547,7 @@ void Gtk::TextBuffer::on_insert(const TextBuffer::iterator& pos, const Glib::ust
   if(base && base->insert_text)
     (*base->insert_text)(gobj(),const_cast<GtkTextIter*>((pos).gobj()),text.c_str(),bytes);
 }
+
 void Gtk::TextBuffer::on_insert_pixbuf(const TextBuffer::iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1883,6 +1557,7 @@ void Gtk::TextBuffer::on_insert_pixbuf(const TextBuffer::iterator& pos, const Gl
   if(base && base->insert_pixbuf)
     (*base->insert_pixbuf)(gobj(),const_cast<GtkTextIter*>((pos).gobj()),Glib::unwrap(pixbuf));
 }
+
 void Gtk::TextBuffer::on_insert_child_anchor(const TextBuffer::iterator& pos, const Glib::RefPtr<ChildAnchor>& anchor)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1892,15 +1567,17 @@ void Gtk::TextBuffer::on_insert_child_anchor(const TextBuffer::iterator& pos, co
   if(base && base->insert_child_anchor)
     (*base->insert_child_anchor)(gobj(),const_cast<GtkTextIter*>((pos).gobj()),Glib::unwrap(anchor));
 }
-void Gtk::TextBuffer::on_erase(const TextBuffer::iterator& start, const TextBuffer::iterator& end)
+
+void Gtk::TextBuffer::on_erase(const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
 {
   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->delete_range)
-    (*base->delete_range)(gobj(),const_cast<GtkTextIter*>((start).gobj()),const_cast<GtkTextIter*>((end).gobj()));
+    (*base->delete_range)(gobj(),const_cast<GtkTextIter*>((range_begin).gobj()),const_cast<GtkTextIter*>((range_end).gobj()));
 }
+
 void Gtk::TextBuffer::on_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1910,6 +1587,7 @@ void Gtk::TextBuffer::on_changed()
   if(base && base->changed)
     (*base->changed)(gobj());
 }
+
 void Gtk::TextBuffer::on_modified_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1919,6 +1597,7 @@ void Gtk::TextBuffer::on_modified_changed()
   if(base && base->modified_changed)
     (*base->modified_changed)(gobj());
 }
+
 void Gtk::TextBuffer::on_mark_set(const TextBuffer::iterator& location, const Glib::RefPtr<TextBuffer::Mark>& mark)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1928,6 +1607,7 @@ void Gtk::TextBuffer::on_mark_set(const TextBuffer::iterator& location, const Gl
   if(base && base->mark_set)
     (*base->mark_set)(gobj(),(location).gobj(),Glib::unwrap(mark));
 }
+
 void Gtk::TextBuffer::on_mark_deleted(const Glib::RefPtr<TextBuffer::Mark>& mark)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1937,6 +1617,7 @@ void Gtk::TextBuffer::on_mark_deleted(const Glib::RefPtr<TextBuffer::Mark>& mark
   if(base && base->mark_deleted)
     (*base->mark_deleted)(gobj(),Glib::unwrap(mark));
 }
+
 void Gtk::TextBuffer::on_apply_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1946,6 +1627,7 @@ void Gtk::TextBuffer::on_apply_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, con
   if(base && base->apply_tag)
     (*base->apply_tag)(gobj(),Glib::unwrap(tag),(range_begin).gobj(),(range_end).gobj());
 }
+
 void Gtk::TextBuffer::on_remove_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1955,6 +1637,7 @@ void Gtk::TextBuffer::on_remove_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, co
   if(base && base->remove_tag)
     (*base->remove_tag)(gobj(),Glib::unwrap(tag),(range_begin).gobj(),(range_end).gobj());
 }
+
 void Gtk::TextBuffer::on_begin_user_action()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1964,6 +1647,7 @@ void Gtk::TextBuffer::on_begin_user_action()
   if(base && base->begin_user_action)
     (*base->begin_user_action)(gobj());
 }
+
 void Gtk::TextBuffer::on_end_user_action()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1973,10 +1657,6 @@ void Gtk::TextBuffer::on_end_user_action()
   if(base && base->end_user_action)
     (*base->end_user_action)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/textbuffer.h b/libs/gtkmm2/gtk/gtkmm/textbuffer.h
index e60387ff4c..7a40dd9526 100644
--- a/libs/gtkmm2/gtk/gtkmm/textbuffer.h
+++ b/libs/gtkmm2/gtk/gtkmm/textbuffer.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTBUFFER_H
 #define _GTKMM_TEXTBUFFER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -188,7 +187,6 @@ public:
   
 
   #ifndef GTKMM_DISABLE_DEPRECATED
-
   /** @deprecated Use set_text()
    */
   void assign(const Glib::ustring& text);
@@ -196,8 +194,7 @@ public:
   /** @deprecated Use set_text()
    */
   void assign(const char* text_begin, const char* text_end);
-  #endif // GTKMM_DISABLE_DEPRECATED
-
+  #endif //GTKMM_DISABLE_DEPRECATED
 
   //TODO: Make all insert() methods have the same return type:
   
@@ -396,31 +393,11 @@ public:
    */
   std::pair<iterator,bool> erase_interactive(const iterator& range_begin, const iterator& range_end, bool default_editable = true);
   
-
-  /** Performs the appropriate action as if the user hit the delete
-   * key with the cursor at the position specified by @a iter. In the
-   * normal case a single character will be deleted, but when
-   * combining accents are involved, more than one character can
-   * be deleted, and when precomposed character and accent combinations
-   * are involved, less than one character will be deleted.
-   * 
-   * Because the buffer is modified, all outstanding iterators become 
-   * invalid after calling this method; however, this method returns 
-   * a valid iterator that points to the location where text was deleted.
-   *
-   * @param iter A position in the buffer.
-   * @param interactive Whether the deletion is caused by user interaction.
-   * @param default_editable Whether the buffer is editable by default.
-   * @result An iterator to the location where text was deleted, if the buffer was modified.
-   *
-   * @newin2p6
-   */
+  
+  //TODO: Document this:
   iterator backspace(const iterator& iter, bool interactive = true, bool default_editable = true);
   
 
-  /** @deprecated Use get_text(const iterator& start, const iterator& end, bool include_hidden_chars) const
-   */
-  
   /** Returns the text in the range [ @a start , @a end ). Excludes undisplayed
    * text (text marked with tags that set the invisibility attribute) if
    *  @a include_hidden_chars  is <tt>false</tt>. Does not include characters
@@ -435,25 +412,6 @@ public:
    */
   Glib::ustring get_text(const iterator& start, const iterator& end, bool include_hidden_chars = true);
 
-  
-  /** Returns the text in the range [ @a start , @a end ). Excludes undisplayed
-   * text (text marked with tags that set the invisibility attribute) if
-   *  @a include_hidden_chars  is <tt>false</tt>. Does not include characters
-   * representing embedded images, so byte and character indexes into
-   * the returned string do <em>not</em> correspond to byte
-   * and character indexes into the buffer. Contrast with
-   * get_slice().
-   * @param start Start of a range.
-   * @param end End of a range.
-   * @param include_hidden_chars Whether to include invisible text.
-   * @return An allocated UTF-8 string.
-   */
-  Glib::ustring get_text(const iterator& start, const iterator& end, bool include_hidden_chars = true) const;
-
-  /** @deprecated Use get_text(bool include_hidden_chars) const.
-   */
-  Glib::ustring get_text(bool include_hidden_chars = true);
-
   /** Returns all the text in the buffer. Excludes undisplayed
    * text (text marked with tags that set the invisibility attribute) if
    *  @a include_hidden_chars  is <tt>false</tt>. Does not include characters
@@ -465,10 +423,8 @@ public:
    * @param include_hidden_chars Whether to include invisible text.
    * @return An allocated UTF-8 string.
    */
-  Glib::ustring get_text(bool include_hidden_chars = true) const;
+  Glib::ustring get_text(bool include_hidden_chars = true);
 
-  /** @deprecated Use get_slice(const iterator& start, const iterator& end, bool include_hidden_chars) const.
-   */
   
   /** Returns the text in the range [ @a start , @a end ). Excludes undisplayed
    * text (text marked with tags that set the invisibility attribute) if
@@ -487,24 +443,6 @@ public:
    */
   Glib::ustring get_slice(const iterator& start, const iterator& end, bool include_hidden_chars = true);
 
-  
-  /** Returns the text in the range [ @a start , @a end ). Excludes undisplayed
-   * text (text marked with tags that set the invisibility attribute) if
-   *  @a include_hidden_chars  is <tt>false</tt>. The returned string includes a
-   * 0xFFFC character whenever the buffer contains
-   * embedded images, so byte and character indexes into
-   * the returned string <em>do</em> correspond to byte
-   * and character indexes into the buffer. Contrast with
-   * get_text(). Note that 0xFFFC can occur in normal
-   * text as well, so it is not a reliable indicator that a pixbuf or
-   * widget is in the buffer.
-   * @param start Start of a range.
-   * @param end End of a range.
-   * @param include_hidden_chars Whether to include invisible text.
-   * @return An allocated UTF-8 string.
-   */
-  Glib::ustring get_slice(const iterator& start, const iterator& end, bool include_hidden_chars = true) const;
-
   iterator insert_pixbuf(const iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
   
 
@@ -571,7 +509,6 @@ public:
    * @param mark A Gtk::TextMark in @a buffer .
    */
   void delete_mark(const Glib::RefPtr<Mark>& mark);
-
   
   /** Returns the mark named @a name  in buffer @a buffer , or <tt>0</tt> if no such
    * mark exists in the buffer.
@@ -737,9 +674,6 @@ public:
   void set_modified(bool setting = true);
 
   
-  bool get_has_selection() const;
-
-  
   /** Adds @a clipboard  to the list of clipboards in which the selection contents
    * of @a buffer  are available. In most cases, @a clipboard  will be the Gtk::Clipboard
    * of type Gdk::SELECTION_PRIMARY for a view of @a buffer .
@@ -798,7 +732,7 @@ public:
    * to be recalculated. This function moves them as a unit, which can
    * be optimized.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param ins Where to put the "insert" mark.
    * @param bound Where to put the "selection_bound" mark.
    */
@@ -831,277 +765,55 @@ public:
   void end_user_action();
 
 
-  //These are only available on the Maemo platform (patched Gtk+):
-
-  
-  /** Sets whether rich text can be pasted and dropped to the text buffer.
-   * 
-   * Since: maemo 1.0
-   * @param can_paste_rich_text Whether rich text pasting and dropping is enabled.
-   */
-
-#ifdef  GTKMM_MAEMO_EXTENSIONS_ENABLED
-  void set_can_paste_rich_text(bool can_paste_rich_text);
-#endif //  GTKMM_MAEMO_EXTENSIONS_ENABLED
-
-  
-  /** 
-   * @return Whether rich text pasting and dropping is enabled
-   * 
-   * Since: maemo 1.0.
-   */
-
-#ifdef  GTKMM_MAEMO_EXTENSIONS_ENABLED
-  bool get_can_paste_rich_text() const;
-#endif //  GTKMM_MAEMO_EXTENSIONS_ENABLED
-
-
-  /** Sets a new rich text format for the widget.
-   * 
-   * Since: maemo 1.0
-   * @param format Name of a collection of tags that the text view supports.
-   */
-
-#ifdef  GTKMM_MAEMO_EXTENSIONS_ENABLED
-  void set_rich_text_format(const Glib::ustring& format);
-#endif //  GTKMM_MAEMO_EXTENSIONS_ENABLED
-
-
-#ifdef GTKMM_MAEMO_EXTENSIONS_ENABLED
-  /** Accept all formats from clipboard
-   *
-   */
-  void set_rich_text_format_all();
-#endif //GTKMM_MAEMO_EXTENSIONS_ENABLED
-
-  
-  /** 
-   * @return The widget's current rich text format.
-   * 
-   * Since: maemo 1.0.
-   */
-
-#ifdef  GTKMM_MAEMO_EXTENSIONS_ENABLED
-  Glib::ustring get_rich_text_format() const;
-#endif //  GTKMM_MAEMO_EXTENSIONS_ENABLED
- 
-
-//TODO: I have commented these out for now because I don't understand what the register_buffer and content_buffer are. murrayc.
- //TODO: Documentation.
- // typedef sigc::slot<guint8*, const Glib::RefPtr<TextBuffer>& /* content_buffer */, const iterator& /* start */, const iterator& /* end */, gsize& /* length */> SlotSerialize;
-
-
-//TODO: Use ArrayHandle, or just use guint8* to be more efficient?
-  // typedef sigc::slot<bool, const Glib::RefPtr<TextBuffer>& /* content_buffer */, iterator& /* iter */, const guint8*  /* data */, gsize /* length */, bool /* create_tags */> SlotDeserialize;
-
-/*
-  Glib::ustring register_serialize_format(const Glib::ustring& mime_type, const SlotSerialize& slot);
-  _IGNORE(gtk_text_buffer_register_serialize_format)
-*/
-
-  
-  Glib::ustring register_serialize_tagset(const Glib::ustring& tagset_name);
-
-/*
-  Glib::ustring register_deserialize_format(const Glib::ustring& mime_type, const SlotDeserialize& slot);
-  _IGNORE(gtk_text_buffer_register_deserialize_format)
-*/
-  
-  Glib::ustring register_deserialize_tagset(const Glib::ustring& tagset_name);
-
-  
-  void unregister_serialize_format(const Glib::ustring& format);
-  
-  void unregister_deserialize_format(const Glib::ustring& format);
-
-//TODO: Wrap property too, if there is one.
-  
-  void set_can_create_tags(const Glib::ustring& format, bool can_create_tags = true);
-  
-  bool get_can_create_tags(const Glib::ustring& format) const;
-
-
-  Glib::StringArrayHandle get_serialize_formats() const;
-  
-  Glib::StringArrayHandle get_deserialize_formats() const;
-  
-
-/*
-//TODO: I have commented these out for now because I don't understand what the register_buffer and content_buffer are. murrayc.
-
-//TODO: Use something other than gsize?
-#m4 _CONVERSION(`const iterator&', `GtkTextIter*',`($3).gobj()')
-  _WRAP_METHOD(guint8* serialize(const Glib::RefPtr<TextBuffer>& content_buffer,
-                                                       const Glib::ustring& format,
-                                                       const iterator& iterstart,
-                                                       const iterator& iterend,
-                                                       gsize& length), gtk_text_buffer_serialize)
-
-//TODO: Is the bool superfluous?
-//TODO: Use an ArrayHandle?
-  _WRAP_METHOD(bool deserialize(const Glib::RefPtr<TextBuffer>& content_buffer,
-                                                       const Glib::ustring& format,
-                                                       const iterator& iter, const guint8* data,
-                                                       gsize length), gtk_text_buffer_deserialize, errthrow)
-*/
-
-
-/**
-   * @par Prototype:
-   * <tt>void %insert(const TextBuffer::iterator& pos, const Glib::ustring& text, int bytes)</tt>
-   */
-
   Glib::SignalProxy3< void,const TextBuffer::iterator&,const Glib::ustring&,int > signal_insert();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %insert_pixbuf(const TextBuffer::iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)</tt>
-   */
-
   Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<Gdk::Pixbuf>& > signal_insert_pixbuf();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %insert_child_anchor(const TextBuffer::iterator& pos, const Glib::RefPtr<ChildAnchor>& anchor)</tt>
-   */
-
   Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<ChildAnchor>& > signal_insert_child_anchor();
 
   
-  /** The delete_range signal is emitted to delete a range from 
-   * a TextBuffer. Note that your handler must not invalidate the
-   * @a start and @a end iters (or has to revalidate them), if it runs before the 
-   * default handler. There is no need to keep the iters valid in handlers
-   * which run after the default handler but
-   * those don't have access to the deleted text.
-   *
-   * @param start the start of the range to be deleted.
-   * @param end the end of the range to be deleted.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %erase(const TextBuffer::iterator& start, const TextBuffer::iterator& end)</tt>
-   */
-
   Glib::SignalProxy2< void,const TextBuffer::iterator&,const TextBuffer::iterator& > signal_erase();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %modified_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_modified_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %mark_set(const TextBuffer::iterator& location, const Glib::RefPtr<TextBuffer::Mark>& mark)</tt>
-   */
-
   Glib::SignalProxy2< void,const TextBuffer::iterator&,const Glib::RefPtr<TextBuffer::Mark>& > signal_mark_set();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %mark_deleted(const Glib::RefPtr<TextBuffer::Mark>& mark)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<TextBuffer::Mark>& > signal_mark_deleted();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %apply_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)</tt>
-   */
-
   Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > signal_apply_tag();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %remove_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)</tt>
-   */
-
   Glib::SignalProxy3< void,const Glib::RefPtr<TextBuffer::Tag>&,const TextBuffer::iterator&,const TextBuffer::iterator& > signal_remove_tag();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %begin_user_action()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_begin_user_action();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %end_user_action()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_end_user_action();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Current text of the buffer.
-   *
-   * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Current text of the buffer.
-   *
-   * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the buffer has some text currently selected.
-   *
-   * 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_has_selection() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_insert(const TextBuffer::iterator& pos, const Glib::ustring& text, int bytes);
   virtual void on_insert_pixbuf(const TextBuffer::iterator& pos, const Glib::RefPtr<Gdk::Pixbuf>& pixbuf);
   virtual void on_insert_child_anchor(const TextBuffer::iterator& pos, const Glib::RefPtr<ChildAnchor>& anchor);
-  virtual void on_erase(const TextBuffer::iterator& start, const TextBuffer::iterator& end);
+  virtual void on_erase(const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end);
   virtual void on_changed();
   virtual void on_modified_changed();
   virtual void on_mark_set(const TextBuffer::iterator& location, const Glib::RefPtr<TextBuffer::Mark>& mark);
@@ -1110,7 +822,6 @@ protected:
   virtual void on_remove_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end);
   virtual void on_begin_user_action();
   virtual void on_end_user_action();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/textchildanchor.cc b/libs/gtkmm2/gtk/gtkmm/textchildanchor.cc
index 517e627448..e44a5050c3 100644
--- a/libs/gtkmm2/gtk/gtkmm/textchildanchor.cc
+++ b/libs/gtkmm2/gtk/gtkmm/textchildanchor.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/textchildanchor.h>
 #include <gtkmm/private/textchildanchor_p.h>
 
@@ -27,6 +26,7 @@
  */
 
 #include <gtk/gtktextchild.h>
+
 namespace
 {
 } // anonymous namespace
@@ -75,19 +75,8 @@ void TextChildAnchor_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* TextChildAnchor_Class::wrap_new(GObject* object)
 {
@@ -157,13 +146,6 @@ bool TextChildAnchor::get_deleted() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/textchildanchor.h b/libs/gtkmm2/gtk/gtkmm/textchildanchor.h
index 0ecc37c1ea..0ee3f68bd0 100644
--- a/libs/gtkmm2/gtk/gtkmm/textchildanchor.h
+++ b/libs/gtkmm2/gtk/gtkmm/textchildanchor.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTCHILDANCHOR_H
 #define _GTKMM_TEXTCHILDANCHOR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -44,11 +43,9 @@ namespace Gtk
 namespace Gtk
 {
 
-/** A TextChildAnchor is a spot in the buffer where child widgets can be "anchored" 
- * (inserted inline, as if they were characters). The anchor can have multiple widgets anchored, 
- * to allow for multiple views.
- *
- * Typedefed as Gtk::TextBuffer::ChildAnchor.
+//TODO: Add a real class description.
+
+/** Typedefed as Gtk::TextBuffer::ChildAnchor.
  * @ingroup TextView
  */
 
@@ -135,17 +132,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/textiter.cc b/libs/gtkmm2/gtk/gtkmm/textiter.cc
index 5c083ddfba..1881fa5574 100644
--- a/libs/gtkmm2/gtk/gtkmm/textiter.cc
+++ b/libs/gtkmm2/gtk/gtkmm/textiter.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/textiter.h>
 #include <gtkmm/private/textiter_p.h>
 
@@ -145,10 +144,10 @@ Glib::RefPtr<TextBuffer> TextIter::get_buffer() const
 {
 
   Glib::RefPtr<TextBuffer> retvalue = Glib::wrap(gtk_text_iter_get_buffer(const_cast<GtkTextIter*>(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 int TextIter::get_offset() const
@@ -210,10 +209,10 @@ Glib::RefPtr<Gdk::Pixbuf> TextIter::get_pixbuf() const
 {
 
   Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_text_iter_get_pixbuf(const_cast<GtkTextIter*>(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::SListHandle< Glib::RefPtr<TextMark> > TextIter::get_marks()
@@ -230,20 +229,20 @@ Glib::RefPtr<TextChildAnchor> TextIter::get_child_anchor()
 {
 
   Glib::RefPtr<TextChildAnchor> retvalue = Glib::wrap(gtk_text_iter_get_child_anchor(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TextChildAnchor> TextIter::get_child_anchor() const
 {
 
   Glib::RefPtr<const TextChildAnchor> retvalue = Glib::wrap(gtk_text_iter_get_child_anchor(const_cast<GtkTextIter*>(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::SListHandle< Glib::RefPtr<TextTag> > TextIter::get_toggled_tags(bool toggled_on)
@@ -426,26 +425,6 @@ bool TextIter::backward_word_starts(int count)
   return gtk_text_iter_backward_word_starts(gobj(), count);
 }
 
-bool TextIter::forward_visible_line()
-{
-  return gtk_text_iter_forward_visible_line(gobj());
-}
-
-bool TextIter::backward_visible_line()
-{
-  return gtk_text_iter_backward_visible_line(gobj());
-}
-
-bool TextIter::forward_visible_line(int count)
-{
-  return gtk_text_iter_forward_visible_lines(gobj(), count);
-}
-
-bool TextIter::backward_visible_lines(int count)
-{
-  return gtk_text_iter_backward_visible_lines(gobj(), count);
-}
-
 bool TextIter::forward_visible_word_end()
 {
   return gtk_text_iter_forward_visible_word_end(gobj());
@@ -528,27 +507,27 @@ bool TextIter::backward_visible_cursor_positions(int count)
 
 void TextIter::set_offset(int char_offset)
 {
-gtk_text_iter_set_offset(gobj(), char_offset); 
+  gtk_text_iter_set_offset(gobj(), char_offset);
 }
 
 void TextIter::set_line(int line_number)
 {
-gtk_text_iter_set_line(gobj(), line_number); 
+  gtk_text_iter_set_line(gobj(), line_number);
 }
 
 void TextIter::set_line_offset(int char_on_line)
 {
-gtk_text_iter_set_line_offset(gobj(), char_on_line); 
+  gtk_text_iter_set_line_offset(gobj(), char_on_line);
 }
 
 void TextIter::set_line_index(int byte_on_line)
 {
-gtk_text_iter_set_line_index(gobj(), byte_on_line); 
+  gtk_text_iter_set_line_index(gobj(), byte_on_line);
 }
 
 void TextIter::forward_to_end()
 {
-gtk_text_iter_forward_to_end(gobj()); 
+  gtk_text_iter_forward_to_end(gobj());
 }
 
 bool TextIter::forward_to_line_end()
@@ -558,12 +537,12 @@ bool TextIter::forward_to_line_end()
 
 void TextIter::set_visible_line_offset(int char_on_line)
 {
-gtk_text_iter_set_visible_line_offset(gobj(), char_on_line); 
+  gtk_text_iter_set_visible_line_offset(gobj(), char_on_line);
 }
 
 void TextIter::set_visible_line_index(int byte_on_line)
 {
-gtk_text_iter_set_visible_line_index(gobj(), byte_on_line); 
+  gtk_text_iter_set_visible_line_index(gobj(), byte_on_line);
 }
 
 bool TextIter::forward_to_tag_toggle(const Glib::RefPtr<TextTag>& tag)
@@ -598,7 +577,7 @@ bool TextIter::in_range(const TextIter& start, const TextIter& end) const
 
 void TextIter::order(TextIter& second)
 {
-gtk_text_iter_order(gobj(), (second).gobj()); 
+  gtk_text_iter_order(gobj(), (second).gobj());
 }
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/textiter.h b/libs/gtkmm2/gtk/gtkmm/textiter.h
index 6b222e898b..5a8cf919d0 100644
--- a/libs/gtkmm2/gtk/gtkmm/textiter.h
+++ b/libs/gtkmm2/gtk/gtkmm/textiter.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTITER_H
 #define _GTKMM_TEXTITER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -695,61 +694,9 @@ public:
    */
   bool backward_word_starts(int count);
 
-  
-  /** Moves @a iter  to the start of the next visible line. Returns <tt>true</tt> if there
-   * was a next line to move to, and <tt>false</tt> if @a iter  was simply moved to
-   * the end of the buffer and is now not dereferenceable, or if @a iter  was
-   * already at the end of the buffer.
-   * @return Whether @a iter  can be dereferenced
-   * 
-   * @newin2p8.
-   */
-  bool forward_visible_line();
-  
-  /** Moves @a iter  to the start of the previous visible line. Returns <tt>true</tt> if
-   *  @a iter  could be moved; i.e. if @a iter  was at character offset 0, this
-   * function returns <tt>false</tt>. Therefore if @a iter  was already on line 0,
-   * but not at the start of the line, @a iter  is snapped to the start of
-   * the line and the function returns <tt>true</tt>. (Note that this implies that
-   * in a loop calling this function, the line number may not change on
-   * every iteration, if your first iteration is on line 0.)
-   * @return Whether @a iter  moved
-   * 
-   * @newin2p8.
-   */
-  bool backward_visible_line();
-  
-  /** Moves @a count  visible lines forward, if possible (if @a count  would move
-   * past the start or end of the buffer, moves to the start or end of
-   * the buffer).  The return value indicates whether the iterator moved
-   * onto a dereferenceable position; if the iterator didn't move, or
-   * moved onto the end iterator, then <tt>false</tt> is returned. If @a count  is 0,
-   * the function does nothing and returns <tt>false</tt>. If @a count  is negative,
-   * moves backward by 0 - @a count  lines.
-   * @param count Number of lines to move forward.
-   * @return Whether @a iter  moved and is dereferenceable
-   * 
-   * @newin2p8.
-   */
-  bool forward_visible_line(int count);
-  
-  /** Moves @a count  visible lines backward, if possible (if @a count  would move
-   * past the start or end of the buffer, moves to the start or end of
-   * the buffer).  The return value indicates whether the iterator moved
-   * onto a dereferenceable position; if the iterator didn't move, or
-   * moved onto the end iterator, then <tt>false</tt> is returned. If @a count  is 0,
-   * the function does nothing and returns <tt>false</tt>. If @a count  is negative,
-   * moves forward by 0 - @a count  lines.
-   * @param count Number of lines to move backward.
-   * @return Whether @a iter  moved and is dereferenceable
-   * 
-   * @newin2p8.
-   */
-  bool backward_visible_lines(int count);
-
   //TODO: Now that there are so many *_visible_ versions of the methods, maybe we should
   //just add a visible=false parameter and therefore halve the number of methods. murrayc
- 
+  
   
   /** Moves forward to the next visible word end. (If @a iter  is currently on a
    * word end, moves forward to the next one after that.) Word breaks
@@ -758,7 +705,7 @@ public:
    * algorithms).
    * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool forward_visible_word_end();
   
@@ -769,7 +716,7 @@ public:
    * algorithms).
    * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool backward_visible_word_start();
   
@@ -777,7 +724,7 @@ public:
    * @param count Number of times to move.
    * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool forward_visible_word_ends(int count);
   
@@ -785,7 +732,7 @@ public:
    * @param count Number of times to move.
    * @return <tt>true</tt> if @a iter  moved and is not the end iterator 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool backward_visible_word_starts(int count);
 
@@ -863,7 +810,7 @@ public:
    * gtk_text_iter_forward_cursor_position() for details.
    * @return <tt>true</tt> if we moved and the new position is dereferenceable
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool forward_visible_cursor_position();
   
@@ -871,7 +818,7 @@ public:
    * gtk_text_iter_backward_cursor_position() for details.
    * @return <tt>true</tt> if we moved and the new position is dereferenceable
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool backward_visible_cursor_position();
   
@@ -880,7 +827,7 @@ public:
    * @param count Number of positions to move.
    * @return <tt>true</tt> if we moved and the new position is dereferenceable
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool forward_visible_cursor_positions(int count);
   
@@ -889,7 +836,7 @@ public:
    * @param count Number of positions to move.
    * @return <tt>true</tt> if we moved and the new position is dereferenceable
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool backward_visible_cursor_positions(int count);
 
@@ -1094,22 +1041,18 @@ TextIter::PredicateAdapter<Predicate>::PredicateAdapter(const Predicate& predica
 template <class Predicate>
 gboolean TextIter::PredicateAdapter<Predicate>::gtk_callback(gunichar uc, void* user_data)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     // This will either use Predicate::operator(), or call a function pointer.
     // The explicit conditional expression avoids relying on an implicit
     // conversion of the return type to int, which might be not available.
     return (static_cast<TextIter::PredicateAdapter<Predicate>*>(user_data)->predicate_(uc)) ? 1 : 0;
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
     return 0;
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 inline
@@ -1263,6 +1206,5 @@ class Value<Gtk::TextIter> : public Glib::Value_Boxed<Gtk::TextIter>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TEXTITER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/textmark.cc b/libs/gtkmm2/gtk/gtkmm/textmark.cc
index 8aadf70324..2252f8715d 100644
--- a/libs/gtkmm2/gtk/gtkmm/textmark.cc
+++ b/libs/gtkmm2/gtk/gtkmm/textmark.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/textmark.h>
 #include <gtkmm/private/textmark_p.h>
 
@@ -93,19 +92,8 @@ void TextMark_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* TextMark_Class::wrap_new(GObject* object)
 {
@@ -150,7 +138,7 @@ GType TextMark::get_base_type()
 
 void TextMark::set_visible(bool setting)
 {
-gtk_text_mark_set_visible(gobj(), static_cast<int>(setting)); 
+  gtk_text_mark_set_visible(gobj(), static_cast<int>(setting));
 }
 
 bool TextMark::get_visible() const
@@ -172,15 +160,20 @@ Glib::RefPtr<TextBuffer> TextMark::get_buffer()
 {
 
   Glib::RefPtr<TextBuffer> retvalue = Glib::wrap(gtk_text_mark_get_buffer(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TextBuffer> TextMark::get_buffer() const
 {
-  return const_cast<TextMark*>(this)->get_buffer();
+
+  Glib::RefPtr<const TextBuffer> retvalue = Glib::wrap(gtk_text_mark_get_buffer(const_cast<GtkTextMark*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 bool TextMark::get_left_gravity() const
@@ -189,13 +182,6 @@ bool TextMark::get_left_gravity() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/textmark.h b/libs/gtkmm2/gtk/gtkmm/textmark.h
index 5616ca20a2..559d6ed71d 100644
--- a/libs/gtkmm2/gtk/gtkmm/textmark.h
+++ b/libs/gtkmm2/gtk/gtkmm/textmark.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTMARK_H
 #define _GTKMM_TEXTMARK_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -171,17 +170,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/texttag.cc b/libs/gtkmm2/gtk/gtkmm/texttag.cc
index 62ebcef88c..f1867ef7b4 100644
--- a/libs/gtkmm2/gtk/gtkmm/texttag.cc
+++ b/libs/gtkmm2/gtk/gtkmm/texttag.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/texttag.h>
 #include <gtkmm/private/texttag_p.h>
 
@@ -29,11 +28,11 @@
 #include <gtkmm/textbuffer.h>
 #include <gtkmm/textiter.h>
 #include <gtk/gtktexttag.h>
+
 namespace
 {
 
-
-static gboolean TextTag_signal_event_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2,void* data)
+gboolean TextTag_signal_event_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > SlotType;
@@ -41,28 +40,24 @@ static gboolean TextTag_signal_event_callback(GtkTextTag* self, GObject* p0,GdkE
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1, Glib::wrap(p2)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean TextTag_signal_event_notify_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2, void* data)
+gboolean TextTag_signal_event_notify_callback(GtkTextTag* self, GObject* p0,GdkEvent* p1,const GtkTextIter* p2, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > SlotType;
@@ -70,35 +65,30 @@ static gboolean TextTag_signal_event_notify_callback(GtkTextTag* self, GObject*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1, Glib::wrap(p2)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo TextTag_signal_event_info =
+const Glib::SignalProxyInfo TextTag_signal_event_info =
 {
   "event",
   (GCallback) &TextTag_signal_event_callback,
   (GCallback) &TextTag_signal_event_notify_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -145,18 +135,10 @@ void TextTag_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->event = &event_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 gboolean TextTag_Class::event_callback(GtkTextTag* self, GObject* p0, GdkEvent* p1, const GtkTextIter* p2)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -169,21 +151,17 @@ gboolean TextTag_Class::event_callback(GtkTextTag* self, GObject* p0, GdkEvent*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_event(Glib::wrap(p0, true)
 , p1, Glib::wrap(p2)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -199,7 +177,6 @@ gboolean TextTag_Class::event_callback(GtkTextTag* self, GObject* p0, GdkEvent*
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TextTag_Class::wrap_new(GObject* object)
@@ -272,7 +249,7 @@ int TextTag::get_priority() const
 
 void TextTag::set_priority(int priority)
 {
-gtk_text_tag_set_priority(gobj(), priority); 
+  gtk_text_tag_set_priority(gobj(), priority);
 }
 
 bool TextTag::event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter)
@@ -287,841 +264,612 @@ Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextI
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> TextTag::property_background() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "background");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_background() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "background");
+}
+
 Glib::PropertyProxy_WriteOnly<Glib::ustring> TextTag::property_foreground() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "foreground");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_foreground() const
+{
+  return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "foreground");
+}
+
 Glib::PropertyProxy<Gdk::Color> TextTag::property_background_gdk() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "background-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> TextTag::property_background_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "background-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::Color> TextTag::property_foreground_gdk() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "foreground-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> TextTag::property_foreground_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "foreground-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_background_stipple() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "background-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_background_stipple() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "background-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_foreground_stipple() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "foreground-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > TextTag::property_foreground_stipple() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "foreground-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> TextTag::property_font() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_font() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::FontDescription> TextTag::property_font_desc() 
 {
   return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::FontDescription> TextTag::property_font_desc() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> TextTag::property_family() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "family");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_family() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Style> TextTag::property_style() 
 {
   return Glib::PropertyProxy<Pango::Style>(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Style> TextTag::property_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Variant> TextTag::property_variant() 
 {
   return Glib::PropertyProxy<Pango::Variant>(this, "variant");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Variant> TextTag::property_variant() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_weight() 
 {
   return Glib::PropertyProxy<int>(this, "weight");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_weight() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Stretch> TextTag::property_stretch() 
 {
   return Glib::PropertyProxy<Pango::Stretch>(this, "stretch");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Stretch> TextTag::property_stretch() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Stretch>(this, "stretch");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_size() 
 {
   return Glib::PropertyProxy<int>(this, "size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_size() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> TextTag::property_size_points() 
 {
   return Glib::PropertyProxy<double>(this, "size-points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> TextTag::property_size_points() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> TextTag::property_scale() 
 {
   return Glib::PropertyProxy<double>(this, "scale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> TextTag::property_scale() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_pixels_above_lines() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-above-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_above_lines() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-above-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_pixels_below_lines() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-below-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_below_lines() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-below-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_pixels_inside_wrap() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-inside-wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_pixels_inside_wrap() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-inside-wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_editable() 
 {
   return Glib::PropertyProxy<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_editable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<WrapMode> TextTag::property_wrap_mode() 
 {
   return Glib::PropertyProxy<WrapMode>(this, "wrap-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<WrapMode> TextTag::property_wrap_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<WrapMode>(this, "wrap-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Justification> TextTag::property_justification() 
 {
   return Glib::PropertyProxy<Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Justification> TextTag::property_justification() const
 {
   return Glib::PropertyProxy_ReadOnly<Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<TextDirection> TextTag::property_direction() 
 {
   return Glib::PropertyProxy<TextDirection>(this, "direction");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<TextDirection> TextTag::property_direction() const
 {
   return Glib::PropertyProxy_ReadOnly<TextDirection>(this, "direction");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_left_margin() 
 {
   return Glib::PropertyProxy<int>(this, "left-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_left_margin() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "left-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_indent() 
 {
   return Glib::PropertyProxy<int>(this, "indent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_indent() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "indent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_strikethrough() 
 {
   return Glib::PropertyProxy<bool>(this, "strikethrough");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_strikethrough() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_right_margin() 
 {
   return Glib::PropertyProxy<int>(this, "right-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_right_margin() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "right-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Underline> TextTag::property_underline() 
 {
   return Glib::PropertyProxy<Pango::Underline>(this, "underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Underline> TextTag::property_underline() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextTag::property_rise() 
 {
   return Glib::PropertyProxy<int>(this, "rise");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextTag::property_rise() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_background_full_height() 
 {
   return Glib::PropertyProxy<bool>(this, "background-full-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_full_height() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-full-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> TextTag::property_language() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "language");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> TextTag::property_language() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "language");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::TabArray> TextTag::property_tabs() 
 {
   return Glib::PropertyProxy<Pango::TabArray>(this, "tabs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::TabArray> TextTag::property_tabs() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::TabArray>(this, "tabs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_invisible() 
 {
   return Glib::PropertyProxy<bool>(this, "invisible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_invisible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "invisible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_background_set() 
 {
   return Glib::PropertyProxy<bool>(this, "background-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_foreground_set() 
 {
   return Glib::PropertyProxy<bool>(this, "foreground-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_foreground_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_background_stipple_set() 
 {
   return Glib::PropertyProxy<bool>(this, "background-stipple-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_stipple_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-stipple-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_foreground_stipple_set() 
 {
   return Glib::PropertyProxy<bool>(this, "foreground-stipple-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_foreground_stipple_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "foreground-stipple-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_family_set() 
 {
   return Glib::PropertyProxy<bool>(this, "family-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_family_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_style_set() 
 {
   return Glib::PropertyProxy<bool>(this, "style-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_style_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_variant_set() 
 {
   return Glib::PropertyProxy<bool>(this, "variant-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_variant_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_weight_set() 
 {
   return Glib::PropertyProxy<bool>(this, "weight-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_weight_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_stretch_set() 
 {
   return Glib::PropertyProxy<bool>(this, "stretch-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_stretch_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_size_set() 
 {
   return Glib::PropertyProxy<bool>(this, "size-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_size_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_scale_set() 
 {
   return Glib::PropertyProxy<bool>(this, "scale-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_scale_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_pixels_above_lines_set() 
 {
   return Glib::PropertyProxy<bool>(this, "pixels-above-lines-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_above_lines_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-above-lines-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_pixels_below_lines_set() 
 {
   return Glib::PropertyProxy<bool>(this, "pixels-below-lines-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_below_lines_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-below-lines-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_pixels_inside_wrap_set() 
 {
   return Glib::PropertyProxy<bool>(this, "pixels-inside-wrap-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_pixels_inside_wrap_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "pixels-inside-wrap-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_editable_set() 
 {
   return Glib::PropertyProxy<bool>(this, "editable-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_editable_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_wrap_mode_set() 
 {
   return Glib::PropertyProxy<bool>(this, "wrap-mode-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_wrap_mode_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "wrap-mode-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_justification_set() 
 {
   return Glib::PropertyProxy<bool>(this, "justification-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_justification_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "justification-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_left_margin_set() 
 {
   return Glib::PropertyProxy<bool>(this, "left-margin-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_left_margin_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "left-margin-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_indent_set() 
 {
   return Glib::PropertyProxy<bool>(this, "indent-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_indent_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "indent-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_strikethrough_set() 
 {
   return Glib::PropertyProxy<bool>(this, "strikethrough-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_strikethrough_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_right_margin_set() 
 {
   return Glib::PropertyProxy<bool>(this, "right-margin-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_right_margin_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "right-margin-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_underline_set() 
 {
   return Glib::PropertyProxy<bool>(this, "underline-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_underline_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_rise_set() 
 {
   return Glib::PropertyProxy<bool>(this, "rise-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_rise_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_background_full_height_set() 
 {
   return Glib::PropertyProxy<bool>(this, "background-full-height-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_background_full_height_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "background-full-height-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_language_set() 
 {
   return Glib::PropertyProxy<bool>(this, "language-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_language_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "language-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_tabs_set() 
 {
   return Glib::PropertyProxy<bool>(this, "tabs-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_tabs_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "tabs-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextTag::property_invisible_set() 
 {
   return Glib::PropertyProxy<bool>(this, "invisible-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextTag::property_invisible_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "invisible-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 bool Gtk::TextTag::on_event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1134,10 +882,6 @@ bool Gtk::TextTag::on_event(const Glib::RefPtr<Glib::Object>& event_object, GdkE
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/texttag.h b/libs/gtkmm2/gtk/gtkmm/texttag.h
index b1620c52fe..c5162c0914 100644
--- a/libs/gtkmm2/gtk/gtkmm/texttag.h
+++ b/libs/gtkmm2/gtk/gtkmm/texttag.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTTAG_H
 #define _GTKMM_TEXTTAG_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -154,58 +153,58 @@ public:
   bool event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter);
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter)</tt>
-   */
-
   Glib::SignalProxy3< bool,const Glib::RefPtr<Glib::Object>&,GdkEvent*,const TextIter& > signal_event();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name used to refer to the text tag. NULL for anonymous tags.
+  /** Name used to refer to the text tag. NULL for anonymous tags.
    *
    * 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_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
  //construct-only.
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Background color as a string.
+  /** Background color as a string.
    *
    * 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_background() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
+/** Background color as a string.
+   *
+   * 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_background() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Foreground color as a string.
+  /** Foreground color as a string.
    *
    * 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_foreground() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
+/** Foreground color as a string.
+   *
+   * 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_foreground() const;
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Background color as a (possibly unallocated) GdkColor.
+  /** Background color as a (possibly unallocated) GdkColor.
    *
    * 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_background_gdk() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Background color as a (possibly unallocated) GdkColor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -213,19 +212,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_background_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Foreground color as a (possibly unallocated) GdkColor.
+  /** Foreground color as a (possibly unallocated) GdkColor.
    *
    * 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_foreground_gdk() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Foreground color as a (possibly unallocated) GdkColor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -233,19 +228,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_foreground_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Bitmap to use as a mask when drawing the text background.
+  /** Bitmap to use as a mask when drawing the text background.
    *
    * 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_background_stipple() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Bitmap to use as a mask when drawing the text background.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -253,19 +244,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_background_stipple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Bitmap to use as a mask when drawing the text foreground.
+  /** Bitmap to use as a mask when drawing the text foreground.
    *
    * 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_foreground_stipple() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Bitmap to use as a mask when drawing the text foreground.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -273,19 +260,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_foreground_stipple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a string
+  /** Font description as a string
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font description as a string
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -293,19 +276,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_font() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a PangoFontDescription struct.
+  /** Font description as a PangoFontDescription struct.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font description as a PangoFontDescription struct.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -313,19 +292,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::FontDescription> property_font_desc() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of the font family
+  /** Name of the font 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<Glib::ustring> property_family() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Name of the font family
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -333,19 +308,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_family() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font style as a PangoStyle
+  /** Font style as a PangoStyle
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font style as a PangoStyle
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -353,19 +324,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Style> property_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font variant as a PangoVariant
+  /** Font variant as a PangoVariant
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font variant as a PangoVariant
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -373,19 +340,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Variant> property_variant() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font weight as an integer
+  /** Font weight as an integer
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font weight as an integer
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -393,19 +356,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_weight() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font stretch as a PangoStretch
+  /** Font stretch as a PangoStretch
    *
    * 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::Stretch> property_stretch() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font stretch as a PangoStretch
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -413,19 +372,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Stretch> property_stretch() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font size in Pango units.
+  /** Font size in Pango 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<int> property_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font size in Pango units.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -433,19 +388,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_size() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font size in points.
+  /** Font size in 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<double> property_size_points() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font size in points.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -453,19 +404,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_size_points() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE.
+  /** Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Font size as a scale factor relative to the default font size. This properly adapts to theme changes etc. so is recommended. Pango predefines some scales such as PANGO_SCALE_X_LARGE.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -473,19 +420,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_scale() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixels of blank space above paragraphs.
+  /** Pixels of blank space above paragraphs.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixels of blank space above paragraphs.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -493,19 +436,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_pixels_above_lines() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixels of blank space below paragraphs.
+  /** Pixels of blank space below paragraphs.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixels of blank space below paragraphs.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -513,19 +452,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_pixels_below_lines() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixels of blank space between wrapped lines in a paragraph.
+  /** Pixels of blank space between wrapped lines in a paragraph.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixels of blank space between wrapped lines in a paragraph.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -533,19 +468,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_pixels_inside_wrap() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the text can be modified by the user.
+  /** Whether the text can be modified by the user.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the text can be modified by the user.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -553,19 +484,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to wrap lines never
+  /** Whether to wrap lines never
    *
    * 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<WrapMode> property_wrap_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to wrap lines never
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -573,19 +500,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<WrapMode> property_wrap_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Left
+  /** Left
    *
    * 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<Justification> property_justification() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Left
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -593,19 +516,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Justification> property_justification() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text direction
+  /** Text 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<TextDirection> property_direction() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text direction
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -613,19 +532,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<TextDirection> property_direction() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the left margin in pixels.
+  /** Width of the left margin 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<int> property_left_margin() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Width of the left margin in pixels.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -633,19 +548,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_left_margin() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Amount to indent the paragraph
+  /** Amount to indent the paragraph
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Amount to indent the paragraph
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -653,19 +564,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_indent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to strike through the text.
+  /** Whether to strike through the 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<bool> property_strikethrough() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to strike through the text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -673,19 +580,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_strikethrough() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the right margin in pixels.
+  /** Width of the right margin 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<int> property_right_margin() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Width of the right margin in pixels.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -693,19 +596,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_right_margin() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Style of underline for this text.
+  /** Style of underline for this 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<Pango::Underline> property_underline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Style of underline for this text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -713,39 +612,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::Underline> property_underline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Offset of text above the baseline (below the baseline if rise is negative) in Pango units.
+  /** Offset of text above the baseline (below the baseline if rise is negative) 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<int> property_rise() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Offset of text above the baseline (below the baseline if rise is negative) in Pango units.
+/** Offset of text above the baseline (below the baseline if rise is negative) 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<int> property_rise() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the background color fills the entire line height or only the height of the tagged characters.
+  /** Whether the background color fills the entire line height or only the height of the tagged characters.
    *
    * 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_background_full_height() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the background color fills the entire line height or only the height of the tagged characters.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -753,19 +644,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_background_full_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The language this text is in
+  /** The language this text is in
    *
    * 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_language() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The language this text is in
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -773,19 +660,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_language() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Custom tabs for this text.
+  /** Custom tabs for this 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<Pango::TabArray> property_tabs() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Custom tabs for this text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -793,39 +676,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::TabArray> property_tabs() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this text is hidden.
+  /** Whether this text is hidden. Not implemented in GTK 2.0.
    *
    * 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_invisible() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this text is hidden.
+/** Whether this text is hidden. Not implemented in GTK 2.0.
    *
    * 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_invisible() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the background color.
+  /** Whether this tag affects the background 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<bool> property_background_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the background color.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -833,19 +708,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_background_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the foreground color.
+  /** Whether this tag affects the foreground 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<bool> property_foreground_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the foreground color.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -853,19 +724,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_foreground_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the background stipple.
+  /** Whether this tag affects the background 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<bool> property_background_stipple_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the background stipple.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -873,19 +740,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_background_stipple_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the foreground stipple.
+  /** Whether this tag affects the foreground 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<bool> property_foreground_stipple_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the foreground stipple.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -893,19 +756,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_foreground_stipple_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font family.
+  /** Whether this tag affects the font 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<bool> property_family_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font family.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -913,19 +772,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_family_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font style.
+  /** Whether this tag affects the font 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<bool> property_style_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font style.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -933,19 +788,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_style_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font variant.
+  /** Whether this tag affects the font 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<bool> property_variant_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font variant.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -953,19 +804,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_variant_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font weight.
+  /** Whether this tag affects the font 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<bool> property_weight_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font weight.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -973,19 +820,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_weight_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font stretch.
+  /** Whether this tag affects the font 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<bool> property_stretch_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font stretch.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -993,19 +836,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_stretch_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font size.
+  /** Whether this tag affects the font 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<bool> property_size_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the font size.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1013,19 +852,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_size_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag scales the font size by a factor.
+  /** Whether this tag scales the font size by a factor.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag scales the font size by a factor.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1033,19 +868,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_scale_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the number of pixels above lines.
+  /** Whether this tag affects the number of 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<bool> property_pixels_above_lines_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the number of pixels above lines.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1053,19 +884,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_pixels_above_lines_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the number of pixels above lines.
+  /** Whether this tag affects the number of 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<bool> property_pixels_below_lines_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the number of pixels above lines.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1073,19 +900,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_pixels_below_lines_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the number of pixels between wrapped lines.
+  /** Whether this tag affects the number of pixels between wrapped 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<bool> property_pixels_inside_wrap_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the number of pixels between wrapped lines.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1093,19 +916,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_pixels_inside_wrap_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects text editability.
+  /** Whether this tag affects text editability.
    *
    * 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_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects text editability.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1113,19 +932,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_editable_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects line wrap mode.
+  /** Whether this tag affects line 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<bool> property_wrap_mode_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects line wrap mode.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1133,19 +948,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_wrap_mode_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects paragraph justification.
+  /** Whether this tag affects paragraph 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<bool> property_justification_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects paragraph justification.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1153,19 +964,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_justification_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the left margin.
+  /** Whether this tag affects the 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<bool> property_left_margin_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the left margin.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1173,19 +980,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_left_margin_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects indentation.
+  /** Whether this tag affects indentation.
    *
    * 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_indent_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects indentation.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1193,19 +996,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_indent_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects strikethrough.
+  /** Whether this tag affects 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<bool> property_strikethrough_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects strikethrough.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1213,19 +1012,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_strikethrough_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the right margin.
+  /** Whether this tag affects the 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<bool> property_right_margin_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the right margin.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1233,19 +1028,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_right_margin_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects underlining.
+  /** Whether this tag affects underlining.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects underlining.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1253,19 +1044,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_underline_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the rise.
+  /** Whether this tag affects the 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<bool> property_rise_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the rise.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1273,19 +1060,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_rise_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects background height.
+  /** Whether this tag affects background 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<bool> property_background_full_height_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects background height.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1293,19 +1076,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_background_full_height_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the language the text is rendered as.
+  /** Whether this tag affects the language the text is rendered as.
    *
    * 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_language_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects the language the text is rendered as.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1313,19 +1092,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_language_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects tabs.
+  /** Whether this tag affects tabs.
    *
    * 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_tabs_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects tabs.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1333,19 +1108,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_tabs_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects text visibility.
+  /** Whether this tag affects text visibility.
    *
    * 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_invisible_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether this tag affects text visibility.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1353,25 +1124,18 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_invisible_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual bool on_event(const Glib::RefPtr<Glib::Object>& event_object, GdkEvent* event, const TextIter& iter);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/texttagtable.cc b/libs/gtkmm2/gtk/gtkmm/texttagtable.cc
index 44b55e773a..c237a5a325 100644
--- a/libs/gtkmm2/gtk/gtkmm/texttagtable.cc
+++ b/libs/gtkmm2/gtk/gtkmm/texttagtable.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/texttagtable.h>
 #include <gtkmm/private/texttagtable_p.h>
 
@@ -30,24 +29,48 @@
 #include <gtk/gtktexttag.h>
 #include <gtk/gtktexttagtable.h>
 
+namespace Gtk
+{
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_ForEach
+{
+public:
+  typedef TextTagTable::SlotForEach SlotType;
+
+  SignalProxy_ForEach(const SlotType& slot);
+  ~SignalProxy_ForEach();
+
+  static void gtk_callback(GtkTextTag* texttag, gpointer data);
+
+protected:
+  SlotType slot_;
+};
 
-static void SignalProxy_ForEach_gtk_callback(GtkTextTag* texttag, gpointer data)
+SignalProxy_ForEach::SignalProxy_ForEach(const SlotType& slot)
 {
-  Gtk::TextTagTable::SlotForEach* the_slot = static_cast<Gtk::TextTagTable::SlotForEach*>(data);
-  if(the_slot)
+  slot_ = slot;
+}
+
+SignalProxy_ForEach::~SignalProxy_ForEach()
+{
+}
+
+void SignalProxy_ForEach::gtk_callback(GtkTextTag* texttag, gpointer data)
+{
+  SignalProxy_ForEach* pSignalProxy = static_cast<SignalProxy_ForEach*>(data);
+  if(pSignalProxy)
   {
     //Use Slot::operator():
-    (*the_slot)(Glib::wrap(texttag, true)); //true = take_copy.
+    (pSignalProxy->slot_)(Glib::wrap(texttag, true)); //true = take_copy.
   }
 }
 
-namespace Gtk
-{
 
 void TextTagTable::foreach(const SlotForEach& slot)
 {
-  //The slot doesn't need to exist for longer than the function call.
-  gtk_text_tag_table_foreach(gobj(),  &SignalProxy_ForEach_gtk_callback, (gpointer)&slot);
+  SignalProxy_ForEach proxy(slot); //It doesn't need to exist for longer than the function call.
+  gtk_text_tag_table_foreach(gobj(),  &SignalProxy_ForEach::gtk_callback, (gpointer)&proxy);
 }
 
 
@@ -57,8 +80,7 @@ void TextTagTable::foreach(const SlotForEach& slot)
 namespace
 {
 
-
-static void TextTagTable_signal_tag_changed_callback(GtkTextTagTable* self, GtkTextTag* p0,gboolean p1,void* data)
+void TextTagTable_signal_tag_changed_callback(GtkTextTagTable* self, GtkTextTag* p0,gboolean p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<TextTag>&,bool > SlotType;
@@ -66,25 +88,21 @@ static void TextTagTable_signal_tag_changed_callback(GtkTextTagTable* self, GtkT
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextTagTable_signal_tag_changed_info =
+const Glib::SignalProxyInfo TextTagTable_signal_tag_changed_info =
 {
   "tag_changed",
   (GCallback) &TextTagTable_signal_tag_changed_callback,
@@ -92,7 +110,7 @@ static const Glib::SignalProxyInfo TextTagTable_signal_tag_changed_info =
 };
 
 
-static void TextTagTable_signal_tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0,void* data)
+void TextTagTable_signal_tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<TextTag>& > SlotType;
@@ -100,24 +118,20 @@ static void TextTagTable_signal_tag_added_callback(GtkTextTagTable* self, GtkTex
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextTagTable_signal_tag_added_info =
+const Glib::SignalProxyInfo TextTagTable_signal_tag_added_info =
 {
   "tag_added",
   (GCallback) &TextTagTable_signal_tag_added_callback,
@@ -125,7 +139,7 @@ static const Glib::SignalProxyInfo TextTagTable_signal_tag_added_info =
 };
 
 
-static void TextTagTable_signal_tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0,void* data)
+void TextTagTable_signal_tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<TextTag>& > SlotType;
@@ -133,31 +147,26 @@ static void TextTagTable_signal_tag_removed_callback(GtkTextTagTable* self, GtkT
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextTagTable_signal_tag_removed_info =
+const Glib::SignalProxyInfo TextTagTable_signal_tag_removed_info =
 {
   "tag_removed",
   (GCallback) &TextTagTable_signal_tag_removed_callback,
   (GCallback) &TextTagTable_signal_tag_removed_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -204,20 +213,12 @@ void TextTagTable_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->tag_changed = &tag_changed_callback;
   klass->tag_added = &tag_added_callback;
   klass->tag_removed = &tag_removed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void TextTagTable_Class::tag_changed_callback(GtkTextTagTable* self, GtkTextTag* p0, gboolean p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -230,21 +231,17 @@ void TextTagTable_Class::tag_changed_callback(GtkTextTagTable* self, GtkTextTag*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_tag_changed(Glib::wrap(p0, true)
 , p1
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -257,6 +254,7 @@ void TextTagTable_Class::tag_changed_callback(GtkTextTagTable* self, GtkTextTag*
       (*base->tag_changed)(self, p0, p1);
   }
 }
+
 void TextTagTable_Class::tag_added_callback(GtkTextTagTable* self, GtkTextTag* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -269,20 +267,16 @@ void TextTagTable_Class::tag_added_callback(GtkTextTagTable* self, GtkTextTag* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_tag_added(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -295,6 +289,7 @@ void TextTagTable_Class::tag_added_callback(GtkTextTagTable* self, GtkTextTag* p
       (*base->tag_added)(self, p0);
   }
 }
+
 void TextTagTable_Class::tag_removed_callback(GtkTextTagTable* self, GtkTextTag* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -307,20 +302,16 @@ void TextTagTable_Class::tag_removed_callback(GtkTextTagTable* self, GtkTextTag*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_tag_removed(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -333,7 +324,6 @@ void TextTagTable_Class::tag_removed_callback(GtkTextTagTable* self, GtkTextTag*
       (*base->tag_removed)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TextTagTable_Class::wrap_new(GObject* object)
@@ -390,27 +380,32 @@ Glib::RefPtr<TextTagTable> TextTagTable::create()
 }
 void TextTagTable::add(const Glib::RefPtr<TextTag>& tag)
 {
-gtk_text_tag_table_add(gobj(), Glib::unwrap(tag)); 
+  gtk_text_tag_table_add(gobj(), Glib::unwrap(tag));
 }
 
 void TextTagTable::remove(const Glib::RefPtr<TextTag>& tag)
 {
-gtk_text_tag_table_remove(gobj(), Glib::unwrap(tag)); 
+  gtk_text_tag_table_remove(gobj(), Glib::unwrap(tag));
 }
 
 Glib::RefPtr<TextTag> TextTagTable::lookup(const Glib::ustring& name)
 {
 
   Glib::RefPtr<TextTag> retvalue = Glib::wrap(gtk_text_tag_table_lookup(gobj(), name.c_str()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TextTag> TextTagTable::lookup(const Glib::ustring& name) const
 {
-  return const_cast<TextTagTable*>(this)->lookup(name);
+
+  Glib::RefPtr<const TextTag> retvalue = Glib::wrap(gtk_text_tag_table_lookup(const_cast<GtkTextTagTable*>(gobj()), name.c_str()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 int TextTagTable::get_size() const
@@ -424,20 +419,17 @@ Glib::SignalProxy2< void,const Glib::RefPtr<TextTag>&,bool > TextTagTable::signa
   return Glib::SignalProxy2< void,const Glib::RefPtr<TextTag>&,bool >(this, &TextTagTable_signal_tag_changed_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > TextTagTable::signal_tag_added()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& >(this, &TextTagTable_signal_tag_added_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > TextTagTable::signal_tag_removed()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& >(this, &TextTagTable_signal_tag_removed_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TextTagTable::on_tag_changed(const Glib::RefPtr<TextTag>& tag, bool size_changed)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -447,6 +439,7 @@ void Gtk::TextTagTable::on_tag_changed(const Glib::RefPtr<TextTag>& tag, bool si
   if(base && base->tag_changed)
     (*base->tag_changed)(gobj(),Glib::unwrap(tag),static_cast<int>(size_changed));
 }
+
 void Gtk::TextTagTable::on_tag_added(const Glib::RefPtr<TextTag>& tag)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -456,6 +449,7 @@ void Gtk::TextTagTable::on_tag_added(const Glib::RefPtr<TextTag>& tag)
   if(base && base->tag_added)
     (*base->tag_added)(gobj(),Glib::unwrap(tag));
 }
+
 void Gtk::TextTagTable::on_tag_removed(const Glib::RefPtr<TextTag>& tag)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -465,10 +459,6 @@ void Gtk::TextTagTable::on_tag_removed(const Glib::RefPtr<TextTag>& tag)
   if(base && base->tag_removed)
     (*base->tag_removed)(gobj(),Glib::unwrap(tag));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/texttagtable.h b/libs/gtkmm2/gtk/gtkmm/texttagtable.h
index ad88a29b71..3c8d8215ac 100644
--- a/libs/gtkmm2/gtk/gtkmm/texttagtable.h
+++ b/libs/gtkmm2/gtk/gtkmm/texttagtable.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTTAGTABLE_H
 #define _GTKMM_TEXTTAGTABLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -144,27 +143,12 @@ public:
   int get_size() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %tag_changed(const Glib::RefPtr<TextTag>& tag, bool size_changed)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::RefPtr<TextTag>&,bool > signal_tag_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %tag_added(const Glib::RefPtr<TextTag>& tag)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > signal_tag_added();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %tag_removed(const Glib::RefPtr<TextTag>& tag)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<TextTag>& > signal_tag_removed();
 
 
@@ -172,20 +156,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_tag_changed(const Glib::RefPtr<TextTag>& tag, bool size_changed);
   virtual void on_tag_added(const Glib::RefPtr<TextTag>& tag);
   virtual void on_tag_removed(const Glib::RefPtr<TextTag>& tag);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/textview.cc b/libs/gtkmm2/gtk/gtkmm/textview.cc
index 53887b9ddc..d4d571371f 100644
--- a/libs/gtkmm2/gtk/gtkmm/textview.cc
+++ b/libs/gtkmm2/gtk/gtkmm/textview.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/textview.h>
 #include <gtkmm/private/textview_p.h>
 
@@ -60,24 +59,22 @@ void TextView::scroll_to(const Glib::RefPtr<TextBuffer::Mark>& mark, double with
   gtk_text_view_scroll_to_mark(gobj(), Glib::unwrap(mark), within_margin, TRUE /* use_align */, xalign, yalign);
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+//deprecated:
 bool TextView::scroll_to_iter(TextBuffer::iterator& iter, double within_margin)
 {
   return scroll_to(iter, within_margin);
 }
 
+//deprecated:
 void TextView::scroll_to_mark(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin)
 {
   scroll_to(mark, within_margin);
 }
-  
+
 void TextView::scroll_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark)
 {
   scroll_to(mark);
 }
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
 } // namespace Gtk
 
@@ -85,8 +82,7 @@ void TextView::scroll_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark)
 namespace
 {
 
-
-static void TextView_signal_set_scroll_adjustments_callback(GtkTextView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+void TextView_signal_set_scroll_adjustments_callback(GtkTextView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
@@ -94,25 +90,21 @@ static void TextView_signal_set_scroll_adjustments_callback(GtkTextView* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextView_signal_set_scroll_adjustments_info =
+const Glib::SignalProxyInfo TextView_signal_set_scroll_adjustments_info =
 {
   "set_scroll_adjustments",
   (GCallback) &TextView_signal_set_scroll_adjustments_callback,
@@ -120,7 +112,7 @@ static const Glib::SignalProxyInfo TextView_signal_set_scroll_adjustments_info =
 };
 
 
-static void TextView_signal_populate_popup_callback(GtkTextView* self, GtkMenu* p0,void* data)
+void TextView_signal_populate_popup_callback(GtkTextView* self, GtkMenu* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Menu* > SlotType;
@@ -128,24 +120,20 @@ static void TextView_signal_populate_popup_callback(GtkTextView* self, GtkMenu*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextView_signal_populate_popup_info =
+const Glib::SignalProxyInfo TextView_signal_populate_popup_info =
 {
   "populate_popup",
   (GCallback) &TextView_signal_populate_popup_callback,
@@ -153,7 +141,7 @@ static const Glib::SignalProxyInfo TextView_signal_populate_popup_info =
 };
 
 
-static const Glib::SignalProxyInfo TextView_signal_set_anchor_info =
+const Glib::SignalProxyInfo TextView_signal_set_anchor_info =
 {
   "set_anchor",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -161,7 +149,7 @@ static const Glib::SignalProxyInfo TextView_signal_set_anchor_info =
 };
 
 
-static void TextView_signal_insert_at_cursor_callback(GtkTextView* self, const gchar* p0,void* data)
+void TextView_signal_insert_at_cursor_callback(GtkTextView* self, const gchar* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::ustring& > SlotType;
@@ -169,31 +157,26 @@ static void TextView_signal_insert_at_cursor_callback(GtkTextView* self, const g
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::convert_const_gchar_ptr_to_ustring(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TextView_signal_insert_at_cursor_info =
+const Glib::SignalProxyInfo TextView_signal_insert_at_cursor_info =
 {
   "insert_at_cursor",
   (GCallback) &TextView_signal_insert_at_cursor_callback,
   (GCallback) &TextView_signal_insert_at_cursor_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -244,21 +227,13 @@ void TextView_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
   klass->populate_popup = &populate_popup_callback;
   klass->set_anchor = &set_anchor_callback;
   klass->insert_at_cursor = &insert_at_cursor_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void TextView_Class::set_scroll_adjustments_callback(GtkTextView* self, GtkAdjustment* p0, GtkAdjustment* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -271,21 +246,17 @@ void TextView_Class::set_scroll_adjustments_callback(GtkTextView* self, GtkAdjus
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_scroll_adjustments(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -298,6 +269,7 @@ void TextView_Class::set_scroll_adjustments_callback(GtkTextView* self, GtkAdjus
       (*base->set_scroll_adjustments)(self, p0, p1);
   }
 }
+
 void TextView_Class::populate_popup_callback(GtkTextView* self, GtkMenu* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -310,20 +282,16 @@ void TextView_Class::populate_popup_callback(GtkTextView* self, GtkMenu* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_populate_popup(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -336,6 +304,7 @@ void TextView_Class::populate_popup_callback(GtkTextView* self, GtkMenu* p0)
       (*base->populate_popup)(self, p0);
   }
 }
+
 void TextView_Class::set_anchor_callback(GtkTextView* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -348,19 +317,15 @@ void TextView_Class::set_anchor_callback(GtkTextView* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_anchor();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -373,6 +338,7 @@ void TextView_Class::set_anchor_callback(GtkTextView* self)
       (*base->set_anchor)(self);
   }
 }
+
 void TextView_Class::insert_at_cursor_callback(GtkTextView* self, const gchar* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -385,20 +351,16 @@ void TextView_Class::insert_at_cursor_callback(GtkTextView* self, const gchar* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_insert_at_cursor(Glib::convert_const_gchar_ptr_to_ustring(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -411,7 +373,6 @@ void TextView_Class::insert_at_cursor_callback(GtkTextView* self, const gchar* p
       (*base->insert_at_cursor)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TextView_Class::wrap_new(GObject* o)
@@ -462,22 +423,27 @@ TextView::TextView()
 
 void TextView::set_buffer(const Glib::RefPtr<TextBuffer>& buffer)
 {
-gtk_text_view_set_buffer(gobj(), Glib::unwrap(buffer)); 
+  gtk_text_view_set_buffer(gobj(), Glib::unwrap(buffer));
 }
 
 Glib::RefPtr<TextBuffer> TextView::get_buffer()
 {
 
   Glib::RefPtr<TextBuffer> retvalue = Glib::wrap(gtk_text_view_get_buffer(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TextBuffer> TextView::get_buffer() const
 {
-  return const_cast<TextView*>(this)->get_buffer();
+
+  Glib::RefPtr<const TextBuffer> retvalue = Glib::wrap(gtk_text_view_get_buffer(const_cast<GtkTextView*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 bool TextView::move_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark)
@@ -492,12 +458,12 @@ bool TextView::place_cursor_onscreen()
 
 void TextView::get_visible_rect(Gdk::Rectangle& visible_rect) const
 {
-gtk_text_view_get_visible_rect(const_cast<GtkTextView*>(gobj()), (visible_rect).gobj()); 
+  gtk_text_view_get_visible_rect(const_cast<GtkTextView*>(gobj()), (visible_rect).gobj());
 }
 
 void TextView::set_cursor_visible(bool setting)
 {
-gtk_text_view_set_cursor_visible(gobj(), static_cast<int>(setting)); 
+  gtk_text_view_set_cursor_visible(gobj(), static_cast<int>(setting));
 }
 
 bool TextView::get_cursor_visible() const
@@ -507,52 +473,57 @@ bool TextView::get_cursor_visible() const
 
 void TextView::get_iter_location(const TextBuffer::iterator& iter, Gdk::Rectangle& location) const
 {
-gtk_text_view_get_iter_location(const_cast<GtkTextView*>(gobj()), (iter).gobj(), (location).gobj()); 
+  gtk_text_view_get_iter_location(const_cast<GtkTextView*>(gobj()), (iter).gobj(), (location).gobj());
 }
 
 void TextView::get_iter_at_location(TextBuffer::iterator& iter, int x, int y) const
 {
-gtk_text_view_get_iter_at_location(const_cast<GtkTextView*>(gobj()), (iter).gobj(), x, y); 
+  gtk_text_view_get_iter_at_location(const_cast<GtkTextView*>(gobj()), (iter).gobj(), x, y);
 }
 
 void TextView::get_iter_at_position(TextBuffer::iterator& iter, int& trailing, int x, int y) const
 {
-gtk_text_view_get_iter_at_position(const_cast<GtkTextView*>(gobj()), (iter).gobj(), &trailing, x, y); 
+  gtk_text_view_get_iter_at_position(const_cast<GtkTextView*>(gobj()), (iter).gobj(), &trailing, x, y);
 }
 
 void TextView::get_line_yrange(const TextBuffer::iterator& iter, int& y, int& height) const
 {
-gtk_text_view_get_line_yrange(const_cast<GtkTextView*>(gobj()), (iter).gobj(), &y, &height); 
+  gtk_text_view_get_line_yrange(const_cast<GtkTextView*>(gobj()), (iter).gobj(), &y, &height);
 }
 
 void TextView::get_line_at_y(TextBuffer::iterator& target_iter, int y, int& line_top) const
 {
-gtk_text_view_get_line_at_y(const_cast<GtkTextView*>(gobj()), (target_iter).gobj(), y, &line_top); 
+  gtk_text_view_get_line_at_y(const_cast<GtkTextView*>(gobj()), (target_iter).gobj(), y, &line_top);
 }
 
 void TextView::buffer_to_window_coords(TextWindowType win, int buffer_x, int buffer_y, int& window_x, int& window_y) const
 {
-gtk_text_view_buffer_to_window_coords(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)), buffer_x, buffer_y, &window_x, &window_y); 
+  gtk_text_view_buffer_to_window_coords(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)), buffer_x, buffer_y, &window_x, &window_y);
 }
 
 void TextView::window_to_buffer_coords(TextWindowType win, int window_x, int window_y, int& buffer_x, int& buffer_y) const
 {
-gtk_text_view_window_to_buffer_coords(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)), window_x, window_y, &buffer_x, &buffer_y); 
+  gtk_text_view_window_to_buffer_coords(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)), window_x, window_y, &buffer_x, &buffer_y);
 }
 
 Glib::RefPtr<Gdk::Window> TextView::get_window(TextWindowType win)
 {
 
   Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_text_view_get_window(gobj(), ((GtkTextWindowType)(win)))));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Window> TextView::get_window(TextWindowType win) const
 {
-  return const_cast<TextView*>(this)->get_window(win);
+
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_text_view_get_window(const_cast<GtkTextView*>(gobj()), ((GtkTextWindowType)(win)))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 TextWindowType TextView::get_window_type(const Glib::RefPtr<Gdk::Window>& window)
@@ -562,7 +533,7 @@ TextWindowType TextView::get_window_type(const Glib::RefPtr<Gdk::Window>& window
 
 void TextView::set_border_window_size(TextWindowType type, int size)
 {
-gtk_text_view_set_border_window_size(gobj(), ((GtkTextWindowType)(type)), size); 
+  gtk_text_view_set_border_window_size(gobj(), ((GtkTextWindowType)(type)), size);
 }
 
 int TextView::get_border_window_size(TextWindowType type) const
@@ -602,22 +573,22 @@ bool TextView::move_visually(TextBuffer::iterator& iter, int count)
 
 void TextView::add_child_at_anchor(Widget& child, const Glib::RefPtr<TextBuffer::ChildAnchor>& anchor)
 {
-gtk_text_view_add_child_at_anchor(gobj(), (child).gobj(), Glib::unwrap(anchor)); 
+  gtk_text_view_add_child_at_anchor(gobj(), (child).gobj(), Glib::unwrap(anchor));
 }
 
 void TextView::add_child_in_window(Widget& child, TextWindowType which_window, int xpos, int ypos)
 {
-gtk_text_view_add_child_in_window(gobj(), (child).gobj(), ((GtkTextWindowType)(which_window)), xpos, ypos); 
+  gtk_text_view_add_child_in_window(gobj(), (child).gobj(), ((GtkTextWindowType)(which_window)), xpos, ypos);
 }
 
 void TextView::move_child(Widget& child, int xpos, int ypos)
 {
-gtk_text_view_move_child(gobj(), (child).gobj(), xpos, ypos); 
+  gtk_text_view_move_child(gobj(), (child).gobj(), xpos, ypos);
 }
 
 void TextView::set_wrap_mode(WrapMode wrap_mode)
 {
-gtk_text_view_set_wrap_mode(gobj(), ((GtkWrapMode)(wrap_mode))); 
+  gtk_text_view_set_wrap_mode(gobj(), ((GtkWrapMode)(wrap_mode)));
 }
 
 WrapMode TextView::get_wrap_mode() const
@@ -627,7 +598,7 @@ WrapMode TextView::get_wrap_mode() const
 
 void TextView::set_editable(bool setting)
 {
-gtk_text_view_set_editable(gobj(), static_cast<int>(setting)); 
+  gtk_text_view_set_editable(gobj(), static_cast<int>(setting));
 }
 
 bool TextView::get_editable() const
@@ -637,7 +608,7 @@ bool TextView::get_editable() const
 
 void TextView::set_pixels_above_lines(int pixels_above_lines)
 {
-gtk_text_view_set_pixels_above_lines(gobj(), pixels_above_lines); 
+  gtk_text_view_set_pixels_above_lines(gobj(), pixels_above_lines);
 }
 
 int TextView::get_pixels_above_lines() const
@@ -647,7 +618,7 @@ int TextView::get_pixels_above_lines() const
 
 void TextView::set_pixels_below_lines(int pixels_below_lines)
 {
-gtk_text_view_set_pixels_below_lines(gobj(), pixels_below_lines); 
+  gtk_text_view_set_pixels_below_lines(gobj(), pixels_below_lines);
 }
 
 int TextView::get_pixels_below_lines() const
@@ -657,7 +628,7 @@ int TextView::get_pixels_below_lines() const
 
 void TextView::set_pixels_inside_wrap(int pixels_inside_wrap)
 {
-gtk_text_view_set_pixels_inside_wrap(gobj(), pixels_inside_wrap); 
+  gtk_text_view_set_pixels_inside_wrap(gobj(), pixels_inside_wrap);
 }
 
 int TextView::get_pixels_inside_wrap() const
@@ -667,7 +638,7 @@ int TextView::get_pixels_inside_wrap() const
 
 void TextView::set_justification(Justification justification)
 {
-gtk_text_view_set_justification(gobj(), ((GtkJustification)(justification))); 
+  gtk_text_view_set_justification(gobj(), ((GtkJustification)(justification)));
 }
 
 Justification TextView::get_justification() const
@@ -677,7 +648,7 @@ Justification TextView::get_justification() const
 
 void TextView::set_left_margin(int left_margin)
 {
-gtk_text_view_set_left_margin(gobj(), left_margin); 
+  gtk_text_view_set_left_margin(gobj(), left_margin);
 }
 
 int TextView::get_left_margin() const
@@ -687,7 +658,7 @@ int TextView::get_left_margin() const
 
 void TextView::set_right_margin(int right_margin)
 {
-gtk_text_view_set_right_margin(gobj(), right_margin); 
+  gtk_text_view_set_right_margin(gobj(), right_margin);
 }
 
 int TextView::get_right_margin() const
@@ -697,7 +668,7 @@ int TextView::get_right_margin() const
 
 void TextView::set_indent(int indent)
 {
-gtk_text_view_set_indent(gobj(), indent); 
+  gtk_text_view_set_indent(gobj(), indent);
 }
 
 int TextView::get_indent() const
@@ -707,7 +678,7 @@ int TextView::get_indent() const
 
 void TextView::set_tabs(Pango::TabArray& tabs)
 {
-gtk_text_view_set_tabs(gobj(), (tabs).gobj()); 
+  gtk_text_view_set_tabs(gobj(), (tabs).gobj());
 }
 
 Pango::TabArray TextView::get_tabs() const
@@ -722,7 +693,7 @@ TextAttributes TextView::get_default_attributes() const
 
 void TextView::set_overwrite(bool overwrite)
 {
-gtk_text_view_set_overwrite(gobj(), static_cast<int>(overwrite)); 
+  gtk_text_view_set_overwrite(gobj(), static_cast<int>(overwrite));
 }
 
 bool TextView::get_overwrite() const
@@ -732,7 +703,7 @@ bool TextView::get_overwrite() const
 
 void TextView::set_accepts_tab(bool accepts_tab)
 {
-gtk_text_view_set_accepts_tab(gobj(), static_cast<int>(accepts_tab)); 
+  gtk_text_view_set_accepts_tab(gobj(), static_cast<int>(accepts_tab));
 }
 
 bool TextView::get_accepts_tab() const
@@ -746,223 +717,163 @@ Glib::SignalProxy2< void,Adjustment*,Adjustment* > TextView::signal_set_scroll_a
   return Glib::SignalProxy2< void,Adjustment*,Adjustment* >(this, &TextView_signal_set_scroll_adjustments_info);
 }
 
-
 Glib::SignalProxy1< void,Menu* > TextView::signal_populate_popup()
 {
   return Glib::SignalProxy1< void,Menu* >(this, &TextView_signal_populate_popup_info);
 }
 
-
 Glib::SignalProxy0< void > TextView::signal_set_anchor()
 {
   return Glib::SignalProxy0< void >(this, &TextView_signal_set_anchor_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::ustring& > TextView::signal_insert_at_cursor()
 {
   return Glib::SignalProxy1< void,const Glib::ustring& >(this, &TextView_signal_insert_at_cursor_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextView::property_pixels_above_lines() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-above-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextView::property_pixels_above_lines() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-above-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextView::property_pixels_below_lines() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-below-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextView::property_pixels_below_lines() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-below-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextView::property_pixels_inside_wrap() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-inside-wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextView::property_pixels_inside_wrap() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-inside-wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextView::property_editable() 
 {
   return Glib::PropertyProxy<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextView::property_editable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<WrapMode> TextView::property_wrap_mode() 
 {
   return Glib::PropertyProxy<WrapMode>(this, "wrap-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<WrapMode> TextView::property_wrap_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<WrapMode>(this, "wrap-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Justification> TextView::property_justification() 
 {
   return Glib::PropertyProxy<Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Justification> TextView::property_justification() const
 {
   return Glib::PropertyProxy_ReadOnly<Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextView::property_left_margin() 
 {
   return Glib::PropertyProxy<int>(this, "left-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextView::property_left_margin() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "left-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextView::property_right_margin() 
 {
   return Glib::PropertyProxy<int>(this, "right-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextView::property_right_margin() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "right-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TextView::property_indent() 
 {
   return Glib::PropertyProxy<int>(this, "indent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TextView::property_indent() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "indent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::TabArray> TextView::property_tabs() 
 {
   return Glib::PropertyProxy<Pango::TabArray>(this, "tabs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::TabArray> TextView::property_tabs() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::TabArray>(this, "tabs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextView::property_cursor_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "cursor-visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextView::property_cursor_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "cursor-visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<TextBuffer> > TextView::property_buffer() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<TextBuffer> >(this, "buffer");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer> > TextView::property_buffer() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer> >(this, "buffer");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextView::property_overwrite() 
 {
   return Glib::PropertyProxy<bool>(this, "overwrite");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextView::property_overwrite() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "overwrite");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TextView::property_accepts_tab() 
 {
   return Glib::PropertyProxy<bool>(this, "accepts-tab");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TextView::property_accepts_tab() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "accepts-tab");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TextView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -972,6 +883,7 @@ void Gtk::TextView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustmen
   if(base && base->set_scroll_adjustments)
     (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
 }
+
 void Gtk::TextView::on_populate_popup(Menu* menu)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -981,6 +893,7 @@ void Gtk::TextView::on_populate_popup(Menu* menu)
   if(base && base->populate_popup)
     (*base->populate_popup)(gobj(),(GtkMenu*)Glib::unwrap(menu));
 }
+
 void Gtk::TextView::on_set_anchor()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -990,6 +903,7 @@ void Gtk::TextView::on_set_anchor()
   if(base && base->set_anchor)
     (*base->set_anchor)(gobj());
 }
+
 void Gtk::TextView::on_insert_at_cursor(const Glib::ustring& str)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -999,10 +913,6 @@ void Gtk::TextView::on_insert_at_cursor(const Glib::ustring& str)
   if(base && base->insert_at_cursor)
     (*base->insert_at_cursor)(gobj(),str.c_str());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/textview.h b/libs/gtkmm2/gtk/gtkmm/textview.h
index 3053df9248..aee4dc44b7 100644
--- a/libs/gtkmm2/gtk/gtkmm/textview.h
+++ b/libs/gtkmm2/gtk/gtkmm/textview.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TEXTVIEW_H
 #define _GTKMM_TEXTVIEW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -136,21 +135,15 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment);
   virtual void on_populate_popup(Menu* menu);
   virtual void on_set_anchor();
   virtual void on_insert_at_cursor(const Glib::ustring& str);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -184,20 +177,19 @@ public:
   Glib::RefPtr<const TextBuffer> get_buffer() const;
 
   #ifndef GTKMM_DISABLE_DEPRECATED
-
   /** @deprecated Use scroll_to().
    */                            
   bool scroll_to_iter(TextBuffer::iterator& iter, double within_margin);
 
   /** @deprecated Use scroll_to().
-   */
+   */ 
   void scroll_to_mark(const Glib::RefPtr<TextBuffer::Mark>& mark, double within_margin);
 
   /** @deprecated Use scroll_to()
    */
   void scroll_mark_onscreen(const Glib::RefPtr<TextBuffer::Mark>& mark);
-  #endif // GTKMM_DISABLE_DEPRECATED
-
+ 
+  #endif //GTKMM_DISABLE_DEPRECATED
 
   /** Scrolls the TextView so that @a iter is on the screen, by scrolling the minimal distance to get the mark onscreen,
    * possibly not scrolling at all. The effective screen for purposes of this function is reduced by a margin of size
@@ -313,16 +305,12 @@ public:
    * those to buffer coordinates with 
    * window_to_buffer_coords().
    * 
-   * Note that this is different from get_iter_at_location(),
+   * Note that this is diffferent from get_iter_at_location(),
    * which returns cursor locations, i.e. positions <em>between</em>
    * characters.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param iter A Gtk::TextIter.
-   * @param trailing Location to store an integer indicating where
-   * in the grapheme the user clicked. It will either be
-   * zero, or the number of characters in the grapheme. 
-   * 0 represents the trailing edge of the grapheme.
    * @param x X position, in buffer coordinates.
    * @param y Y position, in buffer coordinates.
    */
@@ -665,9 +653,9 @@ public:
   void set_tabs(Pango::TabArray& tabs);
   
   /** Gets the default tabs for @a text_view . Tags in the buffer may
-   * override the defaults. The returned array will be empty if
+   * override the defaults. The returned array will be <tt>0</tt> if
    * "standard" (8-space) tabs are used.
-   * @return Copy of default tab array, or an empty array if "standard" tabs are used.
+   * @return Copy of default tab array, or <tt>0</tt> if "standard" tabs are used.
    */
   Pango::TabArray get_tabs() const;
   
@@ -683,7 +671,7 @@ public:
   
   /** Changes the Gtk::TextView overwrite mode.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param overwrite <tt>true</tt> to turn on overwrite mode, <tt>false</tt> to turn it off.
    */
   void set_overwrite(bool overwrite = true);
@@ -691,7 +679,7 @@ public:
   /** Returns whether the Gtk::TextView is in overwrite mode or not.
    * @return Whether @a text_view  is in overwrite mode or not.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_overwrite() const;
   
@@ -700,7 +688,7 @@ public:
    * is <tt>true</tt> a tab character is inserted. If @a accepts_tab  is <tt>false</tt> the keyboard focus
    * is moved to the next widget in the focus chain.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param accepts_tab <tt>true</tt> if pressing the Tab key should insert a tab character, <tt>false</tt>, if pressing the Tab key should move the keyboard focus.
    */
   void set_accepts_tab(bool accepts_tab = true);
@@ -709,57 +697,34 @@ public:
    * set_accepts_tab().
    * @return <tt>true</tt> if pressing the Tab key inserts a tab character, <tt>false</tt> if pressing the Tab key moves the keyboard focus.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_accepts_tab() const;
     
   
-/**
-   * @par Prototype:
-   * <tt>void %set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)</tt>
-   */
-
   Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %populate_popup(Menu* menu)</tt>
-   */
-
   Glib::SignalProxy1< void,Menu* > signal_populate_popup();
 
 
-/**
-   * @par Prototype:
-   * <tt>void %set_anchor()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_set_anchor();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %insert_at_cursor(const Glib::ustring& str)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::ustring& > signal_insert_at_cursor();
 
   
   //Keybinding signals:
   
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixels of blank space above paragraphs.
+  /** Pixels of blank space above paragraphs.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixels of blank space above paragraphs.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -767,19 +732,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_pixels_above_lines() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixels of blank space below paragraphs.
+  /** Pixels of blank space below paragraphs.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixels of blank space below paragraphs.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -787,19 +748,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_pixels_below_lines() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Pixels of blank space between wrapped lines in a paragraph.
+  /** Pixels of blank space between wrapped lines in a paragraph.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Pixels of blank space between wrapped lines in a paragraph.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -807,19 +764,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_pixels_inside_wrap() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the text can be modified by the user.
+  /** Whether the text can be modified by the user.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the text can be modified by the user.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -827,19 +780,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_editable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to wrap lines never
+  /** Whether to wrap lines never
    *
    * 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<WrapMode> property_wrap_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to wrap lines never
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -847,19 +796,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<WrapMode> property_wrap_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Left
+  /** Left
    *
    * 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<Justification> property_justification() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Left
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -867,19 +812,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Justification> property_justification() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the left margin in pixels.
+  /** Width of the left margin 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<int> property_left_margin() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Width of the left margin in pixels.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -887,19 +828,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_left_margin() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the right margin in pixels.
+  /** Width of the right margin 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<int> property_right_margin() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Width of the right margin in pixels.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -907,19 +844,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_right_margin() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Amount to indent the paragraph
+  /** Amount to indent the paragraph
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Amount to indent the paragraph
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -927,19 +860,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_indent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Custom tabs for this text.
+  /** Custom tabs for this 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<Pango::TabArray> property_tabs() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Custom tabs for this text.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -947,19 +876,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::TabArray> property_tabs() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If the insertion cursor is shown.
+  /** If the insertion cursor is shown.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If the insertion cursor is shown.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -967,19 +892,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_cursor_visible() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The buffer which is displayed.
+  /** The buffer which is displayed.
    *
    * 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<TextBuffer> > property_buffer() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The buffer which is displayed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -987,19 +908,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer> > property_buffer() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether entered text overwrites existing contents.
+  /** Whether entered text overwrites existing contents.
    *
    * 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_overwrite() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether entered text overwrites existing contents.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1007,19 +924,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_overwrite() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether Tab will result in a tab character being entered.
+  /** Whether Tab will result in a tab character being entered.
    *
    * 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_accepts_tab() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether Tab will result in a tab character being entered.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1027,7 +940,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_accepts_tab() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -1043,8 +955,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::TextView* wrap(GtkTextView* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TEXTVIEW_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/toggleaction.cc b/libs/gtkmm2/gtk/gtkmm/toggleaction.cc
index ff78ea03ad..f9892927db 100644
--- a/libs/gtkmm2/gtk/gtkmm/toggleaction.cc
+++ b/libs/gtkmm2/gtk/gtkmm/toggleaction.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/toggleaction.h>
 #include <gtkmm/private/toggleaction_p.h>
 
@@ -55,15 +54,13 @@ Glib::RefPtr<ToggleAction> ToggleAction::create(const Glib::ustring& name, const
 namespace
 {
 
-
-static const Glib::SignalProxyInfo ToggleAction_signal_toggled_info =
+const Glib::SignalProxyInfo ToggleAction_signal_toggled_info =
 {
   "toggled",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -110,18 +107,10 @@ void ToggleAction_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->toggled = &toggled_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ToggleAction_Class::toggled_callback(GtkToggleAction* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -134,19 +123,15 @@ void ToggleAction_Class::toggled_callback(GtkToggleAction* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggled();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -159,7 +144,6 @@ void ToggleAction_Class::toggled_callback(GtkToggleAction* self)
       (*base->toggled)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ToggleAction_Class::wrap_new(GObject* object)
@@ -216,12 +200,12 @@ Glib::RefPtr<ToggleAction> ToggleAction::create()
 }
 void ToggleAction::toggled()
 {
-gtk_toggle_action_toggled(gobj()); 
+  gtk_toggle_action_toggled(gobj());
 }
 
 void ToggleAction::set_active(bool is_active)
 {
-gtk_toggle_action_set_active(gobj(), static_cast<int>(is_active)); 
+  gtk_toggle_action_set_active(gobj(), static_cast<int>(is_active));
 }
 
 bool ToggleAction::get_active() const
@@ -231,7 +215,7 @@ bool ToggleAction::get_active() const
 
 void ToggleAction::set_draw_as_radio(bool draw_as_radio)
 {
-gtk_toggle_action_set_draw_as_radio(gobj(), static_cast<int>(draw_as_radio)); 
+  gtk_toggle_action_set_draw_as_radio(gobj(), static_cast<int>(draw_as_radio));
 }
 
 bool ToggleAction::get_draw_as_radio() const
@@ -246,22 +230,17 @@ Glib::SignalProxy0< void > ToggleAction::signal_toggled()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToggleAction::property_draw_as_radio() 
 {
   return Glib::PropertyProxy<bool>(this, "draw-as-radio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToggleAction::property_draw_as_radio() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-as-radio");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ToggleAction::on_toggled()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -271,10 +250,6 @@ void Gtk::ToggleAction::on_toggled()
   if(base && base->toggled)
     (*base->toggled)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/toggleaction.h b/libs/gtkmm2/gtk/gtkmm/toggleaction.h
index ab127fd580..b44872026e 100644
--- a/libs/gtkmm2/gtk/gtkmm/toggleaction.h
+++ b/libs/gtkmm2/gtk/gtkmm/toggleaction.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TOGGLEACTION_H
 #define _GTKMM_TOGGLEACTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -99,13 +98,13 @@ public:
   
   /** Emits the "toggled" signal on the toggle action.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void toggled();
   
   /** Sets the checked state on the toggle action.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param is_active Whether the action should be checked or not.
    */
   void set_active(bool is_active = true);
@@ -113,13 +112,13 @@ public:
   /** Returns the checked state of the toggle action.
    * @return The checked state of the toggle action
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_active() const;
   
   /** Sets whether the action should have proxies like a radio action.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param draw_as_radio Whether the action should have proxies like a radio 
    * action.
    */
@@ -128,30 +127,22 @@ public:
   /** Returns whether the action should have proxies like a radio action.
    * @return Whether the action should have proxies like a radio action.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_draw_as_radio() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %toggled()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_toggled();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the proxies for this action look like radio action proxies.
+  /** Whether the proxies for this action look like radio action proxies.
    *
    * 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_draw_as_radio() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the proxies for this action look like radio action proxies.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -159,25 +150,18 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_draw_as_radio() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
           
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_toggled();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/togglebutton.cc b/libs/gtkmm2/gtk/gtkmm/togglebutton.cc
index dd2041018e..e7600d0406 100644
--- a/libs/gtkmm2/gtk/gtkmm/togglebutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/togglebutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/togglebutton.h>
 #include <gtkmm/private/togglebutton_p.h>
 
@@ -37,27 +36,19 @@ ToggleButton::ToggleButton(const Glib::ustring& label, bool mnemonic)
   Gtk::Button(Glib::ConstructParams(togglebutton_class_.init(), "label",label.c_str(),"use_underline",gboolean(mnemonic), (char*) 0))
 {}
 
-ToggleButton::ToggleButton(const StockID& stock_id)
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Gtk::Button(Glib::ConstructParams(togglebutton_class_.init(), "use_stock",1,"label",stock_id.get_c_str(), (char*) 0))
-{}
-
 } // namespace Gtk
 
 
 namespace
 {
 
-
-static const Glib::SignalProxyInfo ToggleButton_signal_toggled_info =
+const Glib::SignalProxyInfo ToggleButton_signal_toggled_info =
 {
   "toggled",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -102,18 +93,10 @@ void ToggleButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->toggled = &toggled_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ToggleButton_Class::toggled_callback(GtkToggleButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -126,19 +109,15 @@ void ToggleButton_Class::toggled_callback(GtkToggleButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggled();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -151,7 +130,6 @@ void ToggleButton_Class::toggled_callback(GtkToggleButton* self)
       (*base->toggled)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ToggleButton_Class::wrap_new(GObject* o)
@@ -202,7 +180,7 @@ ToggleButton::ToggleButton()
 
 void ToggleButton::set_mode(bool draw_indicator)
 {
-gtk_toggle_button_set_mode(gobj(), static_cast<int>(draw_indicator)); 
+  gtk_toggle_button_set_mode(gobj(), static_cast<int>(draw_indicator));
 }
 
 bool ToggleButton::get_mode() const
@@ -212,7 +190,7 @@ bool ToggleButton::get_mode() const
 
 void ToggleButton::set_active(bool is_active)
 {
-gtk_toggle_button_set_active(gobj(), static_cast<int>(is_active)); 
+  gtk_toggle_button_set_active(gobj(), static_cast<int>(is_active));
 }
 
 bool ToggleButton::get_active() const
@@ -222,7 +200,7 @@ bool ToggleButton::get_active() const
 
 void ToggleButton::set_inconsistent(bool setting)
 {
-gtk_toggle_button_set_inconsistent(gobj(), static_cast<int>(setting)); 
+  gtk_toggle_button_set_inconsistent(gobj(), static_cast<int>(setting));
 }
 
 bool ToggleButton::get_inconsistent() const
@@ -232,7 +210,7 @@ bool ToggleButton::get_inconsistent() const
 
 void ToggleButton::toggled()
 {
-gtk_toggle_button_toggled(gobj()); 
+  gtk_toggle_button_toggled(gobj());
 }
 
 
@@ -242,50 +220,37 @@ Glib::SignalProxy0< void > ToggleButton::signal_toggled()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToggleButton::property_active() 
 {
   return Glib::PropertyProxy<bool>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToggleButton::property_active() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToggleButton::property_inconsistent() 
 {
   return Glib::PropertyProxy<bool>(this, "inconsistent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToggleButton::property_inconsistent() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "inconsistent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToggleButton::property_draw_indicator() 
 {
   return Glib::PropertyProxy<bool>(this, "draw-indicator");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToggleButton::property_draw_indicator() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "draw-indicator");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ToggleButton::on_toggled()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -295,10 +260,6 @@ void Gtk::ToggleButton::on_toggled()
   if(base && base->toggled)
     (*base->toggled)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/togglebutton.h b/libs/gtkmm2/gtk/gtkmm/togglebutton.h
index f4fff2ef09..df0da34b34 100644
--- a/libs/gtkmm2/gtk/gtkmm/togglebutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/togglebutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TOGGLEBUTTON_H
 #define _GTKMM_TOGGLEBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -91,18 +90,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_toggled();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -124,19 +117,13 @@ public:
    * to add a widget to this button since it already contains a Gtk::Label
    */
   explicit ToggleButton(const Glib::ustring& label, bool mnemonic = false);
-
-  /** Creates a toggle button containing the image and text from a stock item.
-   * Stock ids have identifiers like Gtk::Stock::OK and Gtk::Stock::APPLY.
-   * @param stock_id The stock item.
-   */
-  explicit ToggleButton(const StockID& stock_id);
-  
   
+
   /** Sets whether the button is displayed as a separate indicator and label.
    * You can call this function on a checkbutton or a radiobutton with
    *  @a draw_indicator  = <tt>false</tt> to make the button look like a normal button
    * 
-   * This function only affects instances of classes like Gtk::CheckButton
+   * This function only effects instances of classes like Gtk::CheckButton
    * and Gtk::RadioButton that derive from Gtk::ToggleButton,
    * not instances of Gtk::ToggleButton itself.
    * @param draw_indicator If <tt>true</tt>, draw the button as a separate indicator
@@ -177,28 +164,18 @@ public:
   
   void toggled();
 
-  /** Emitted whenever the toggle tool button changes state.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %toggled()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_toggled();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If the toggle button should be pressed in or not.
+  /** If the toggle button should be pressed in 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_active() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If the toggle button should be pressed in or not.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -206,39 +183,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_active() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If the toggle button is in an in between state.
+  /** If the toggle button is in an in-between state.
    *
    * 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_inconsistent() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** If the toggle button is in an in between state.
+/** If the toggle button is in an in-between state.
    *
    * 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_inconsistent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If the toggle part of the button is displayed.
+  /** If the toggle part of the button is displayed.
    *
    * 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_draw_indicator() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If the toggle part of the button is displayed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -246,7 +215,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_draw_indicator() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -262,8 +230,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ToggleButton* wrap(GtkToggleButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TOGGLEBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc
index 57a80db694..3aadab7948 100644
--- a/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/toggletoolbutton.h>
 #include <gtkmm/private/toggletoolbutton_p.h>
 
@@ -51,15 +50,13 @@ ToggleToolButton::ToggleToolButton(Widget& icon_widget, const Glib::ustring& lab
 namespace
 {
 
-
-static const Glib::SignalProxyInfo ToggleToolButton_signal_toggled_info =
+const Glib::SignalProxyInfo ToggleToolButton_signal_toggled_info =
 {
   "toggled",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -104,18 +101,10 @@ void ToggleToolButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->toggled = &toggled_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ToggleToolButton_Class::toggled_callback(GtkToggleToolButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -128,19 +117,15 @@ void ToggleToolButton_Class::toggled_callback(GtkToggleToolButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toggled();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -153,7 +138,6 @@ void ToggleToolButton_Class::toggled_callback(GtkToggleToolButton* self)
       (*base->toggled)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ToggleToolButton_Class::wrap_new(GObject* o)
@@ -211,7 +195,7 @@ ToggleToolButton::ToggleToolButton(const Gtk::StockID& stock_id)
 
 void ToggleToolButton::set_active(bool is_active)
 {
-gtk_toggle_tool_button_set_active(gobj(), static_cast<int>(is_active)); 
+  gtk_toggle_tool_button_set_active(gobj(), static_cast<int>(is_active));
 }
 
 bool ToggleToolButton::get_active() const
@@ -226,7 +210,6 @@ Glib::SignalProxy0< void > ToggleToolButton::signal_toggled()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ToggleToolButton::on_toggled()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -236,10 +219,6 @@ void Gtk::ToggleToolButton::on_toggled()
   if(base && base->toggled)
     (*base->toggled)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.h b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.h
index f9f5936a8d..331d65976e 100644
--- a/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/toggletoolbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TOGGLETOOLBUTTON_H
 #define _GTKMM_TOGGLETOOLBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -90,18 +89,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_toggled();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -142,7 +135,7 @@ public:
    * want the GtkToggleButton to be 'pressed in', and <tt>false</tt> to raise it.
    * This action causes the toggled signal to be emitted.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param is_active Whether @a button  should be active.
    */
   void set_active(bool is_active = true);
@@ -151,16 +144,11 @@ public:
    * Returns <tt>true</tt> if the toggle button is pressed in and <tt>false</tt> if it is raised.
    * @return <tt>true</tt> if the toggle tool button is pressed in, <tt>false</tt> if not
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_active() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %toggled()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_toggled();
 
 
@@ -177,8 +165,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ToggleToolButton* wrap(GtkToggleToolButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TOGGLETOOLBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbar.cc b/libs/gtkmm2/gtk/gtkmm/toolbar.cc
index 8a802bbc3f..a8d10a7dde 100644
--- a/libs/gtkmm2/gtk/gtkmm/toolbar.cc
+++ b/libs/gtkmm2/gtk/gtkmm/toolbar.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/toolbar.h>
 #include <gtkmm/private/toolbar_p.h>
 
@@ -104,8 +103,7 @@ void Toolbar::unset_drop_highlight_item()
 namespace
 {
 
-
-static void Toolbar_signal_orientation_changed_callback(GtkToolbar* self, GtkOrientation p0,void* data)
+void Toolbar_signal_orientation_changed_callback(GtkToolbar* self, GtkOrientation p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Orientation > SlotType;
@@ -113,24 +111,20 @@ static void Toolbar_signal_orientation_changed_callback(GtkToolbar* self, GtkOri
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((Orientation)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Toolbar_signal_orientation_changed_info =
+const Glib::SignalProxyInfo Toolbar_signal_orientation_changed_info =
 {
   "orientation_changed",
   (GCallback) &Toolbar_signal_orientation_changed_callback,
@@ -138,7 +132,7 @@ static const Glib::SignalProxyInfo Toolbar_signal_orientation_changed_info =
 };
 
 
-static void Toolbar_signal_toolbar_style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0,void* data)
+void Toolbar_signal_toolbar_style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,ToolbarStyle > SlotType;
@@ -146,24 +140,20 @@ static void Toolbar_signal_toolbar_style_changed_callback(GtkToolbar* self, GtkT
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((ToolbarStyle)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Toolbar_signal_toolbar_style_changed_info =
+const Glib::SignalProxyInfo Toolbar_signal_toolbar_style_changed_info =
 {
   "style_changed",
   (GCallback) &Toolbar_signal_toolbar_style_changed_callback,
@@ -171,7 +161,7 @@ static const Glib::SignalProxyInfo Toolbar_signal_toolbar_style_changed_info =
 };
 
 
-static gboolean Toolbar_signal_popup_context_menu_callback(GtkToolbar* self, gint p0,gint p1,gint p2,void* data)
+gboolean Toolbar_signal_popup_context_menu_callback(GtkToolbar* self, gint p0,gint p1,gint p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,int,int,int > SlotType;
@@ -179,29 +169,25 @@ static gboolean Toolbar_signal_popup_context_menu_callback(GtkToolbar* self, gin
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0
 , p1
 , p2
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Toolbar_signal_popup_context_menu_notify_callback(GtkToolbar* self, gint p0,gint p1,gint p2, void* data)
+gboolean Toolbar_signal_popup_context_menu_notify_callback(GtkToolbar* self, gint p0,gint p1,gint p2, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,int,int,int > SlotType;
@@ -209,36 +195,31 @@ static gboolean Toolbar_signal_popup_context_menu_notify_callback(GtkToolbar* se
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 , p1
 , p2
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Toolbar_signal_popup_context_menu_info =
+const Glib::SignalProxyInfo Toolbar_signal_popup_context_menu_info =
 {
   "popup_context_menu",
   (GCallback) &Toolbar_signal_popup_context_menu_callback,
   (GCallback) &Toolbar_signal_popup_context_menu_notify_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -283,20 +264,12 @@ void Toolbar_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->orientation_changed = &orientation_changed_callback;
   klass->style_changed = &style_changed_callback;
   klass->popup_context_menu = &popup_context_menu_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Toolbar_Class::orientation_changed_callback(GtkToolbar* self, GtkOrientation p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -309,20 +282,16 @@ void Toolbar_Class::orientation_changed_callback(GtkToolbar* self, GtkOrientatio
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_orientation_changed(((Orientation)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -335,6 +304,7 @@ void Toolbar_Class::orientation_changed_callback(GtkToolbar* self, GtkOrientatio
       (*base->orientation_changed)(self, p0);
   }
 }
+
 void Toolbar_Class::style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -347,20 +317,16 @@ void Toolbar_Class::style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toolbar_style_changed(((ToolbarStyle)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -373,6 +339,7 @@ void Toolbar_Class::style_changed_callback(GtkToolbar* self, GtkToolbarStyle p0)
       (*base->style_changed)(self, p0);
   }
 }
+
 gboolean Toolbar_Class::popup_context_menu_callback(GtkToolbar* self, gint p0, gint p1, gint p2)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -385,22 +352,18 @@ gboolean Toolbar_Class::popup_context_menu_callback(GtkToolbar* self, gint p0, g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_popup_context_menu(p0
 , p1
 , p2
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -416,7 +379,6 @@ gboolean Toolbar_Class::popup_context_menu_callback(GtkToolbar* self, gint p0, g
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Toolbar_Class::wrap_new(GObject* o)
@@ -467,7 +429,7 @@ Toolbar::Toolbar()
 
 void Toolbar::insert(ToolItem& item, int pos)
 {
-gtk_toolbar_insert(gobj(), (item).gobj(), pos); 
+  gtk_toolbar_insert(gobj(), (item).gobj(), pos);
 }
 
 int Toolbar::get_item_index(const ToolItem& item) const
@@ -487,7 +449,7 @@ ToolItem* Toolbar::get_nth_item(int n)
 
 const ToolItem* Toolbar::get_nth_item(int n) const
 {
-  return const_cast<Toolbar*>(this)->get_nth_item(n);
+  return Glib::wrap(gtk_toolbar_get_nth_item(const_cast<GtkToolbar*>(gobj()), n));
 }
 
 bool Toolbar::get_show_arrow() const
@@ -497,12 +459,12 @@ bool Toolbar::get_show_arrow() const
 
 void Toolbar::set_show_arrow(bool show_arrow)
 {
-gtk_toolbar_set_show_arrow(gobj(), static_cast<int>(show_arrow)); 
+  gtk_toolbar_set_show_arrow(gobj(), static_cast<int>(show_arrow));
 }
 
 void Toolbar::set_orientation(Orientation orientation)
 {
-gtk_toolbar_set_orientation(gobj(), ((GtkOrientation)(orientation))); 
+  gtk_toolbar_set_orientation(gobj(), ((GtkOrientation)(orientation)));
 }
 
 Orientation Toolbar::get_orientation() const
@@ -512,7 +474,7 @@ Orientation Toolbar::get_orientation() const
 
 void Toolbar::set_toolbar_style(ToolbarStyle style)
 {
-gtk_toolbar_set_style(gobj(), ((GtkToolbarStyle)(style))); 
+  gtk_toolbar_set_style(gobj(), ((GtkToolbarStyle)(style)));
 }
 
 ToolbarStyle Toolbar::get_toolbar_style() const
@@ -522,7 +484,7 @@ ToolbarStyle Toolbar::get_toolbar_style() const
 
 void Toolbar::set_tooltips(bool enable)
 {
-gtk_toolbar_set_tooltips(gobj(), static_cast<int>(enable)); 
+  gtk_toolbar_set_tooltips(gobj(), static_cast<int>(enable));
 }
 
 bool Toolbar::get_tooltips() const
@@ -532,7 +494,7 @@ bool Toolbar::get_tooltips() const
 
 void Toolbar::unset_toolbar_style()
 {
-gtk_toolbar_unset_style(gobj()); 
+  gtk_toolbar_unset_style(gobj());
 }
 
 IconSize Toolbar::get_icon_size() const
@@ -552,77 +514,62 @@ int Toolbar::get_drop_index(int x, int y) const
 
 void Toolbar::set_drop_highlight_item(ToolItem& tool_item, int index)
 {
-gtk_toolbar_set_drop_highlight_item(gobj(), (tool_item).gobj(), index); 
+  gtk_toolbar_set_drop_highlight_item(gobj(), (tool_item).gobj(), index);
 }
 
- Tooltips* Toolbar::get_tooltips_object() const
+Tooltips* Toolbar::get_tooltips_object() const
 {
   return Glib::wrap(gobj()->tooltips);
 }
- 
+
 
 Glib::SignalProxy1< void,Orientation > Toolbar::signal_orientation_changed()
 {
   return Glib::SignalProxy1< void,Orientation >(this, &Toolbar_signal_orientation_changed_info);
 }
 
-
 Glib::SignalProxy1< void,ToolbarStyle > Toolbar::signal_toolbar_style_changed()
 {
   return Glib::SignalProxy1< void,ToolbarStyle >(this, &Toolbar_signal_toolbar_style_changed_info);
 }
 
-
 Glib::SignalProxy3< bool,int,int,int > Toolbar::signal_popup_context_menu()
 {
   return Glib::SignalProxy3< bool,int,int,int >(this, &Toolbar_signal_popup_context_menu_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Orientation> Toolbar::property_orientation() 
 {
   return Glib::PropertyProxy<Orientation>(this, "orientation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Orientation> Toolbar::property_orientation() const
 {
   return Glib::PropertyProxy_ReadOnly<Orientation>(this, "orientation");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ToolbarStyle> Toolbar::property_toolbar_style() 
 {
   return Glib::PropertyProxy<ToolbarStyle>(this, "toolbar-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ToolbarStyle> Toolbar::property_toolbar_style() const
 {
   return Glib::PropertyProxy_ReadOnly<ToolbarStyle>(this, "toolbar-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Toolbar::property_show_arrow() 
 {
   return Glib::PropertyProxy<bool>(this, "show-arrow");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Toolbar::property_show_arrow() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "show-arrow");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Toolbar::on_orientation_changed(Orientation orientation)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -632,6 +579,7 @@ void Gtk::Toolbar::on_orientation_changed(Orientation orientation)
   if(base && base->orientation_changed)
     (*base->orientation_changed)(gobj(),((GtkOrientation)(orientation)));
 }
+
 void Gtk::Toolbar::on_toolbar_style_changed(ToolbarStyle style)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -641,6 +589,7 @@ void Gtk::Toolbar::on_toolbar_style_changed(ToolbarStyle style)
   if(base && base->style_changed)
     (*base->style_changed)(gobj(),((GtkToolbarStyle)(style)));
 }
+
 bool Gtk::Toolbar::on_popup_context_menu(int x, int y, int button_number)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -653,10 +602,6 @@ bool Gtk::Toolbar::on_popup_context_menu(int x, int y, int button_number)
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbar.h b/libs/gtkmm2/gtk/gtkmm/toolbar.h
index 593c7db298..8cf6431014 100644
--- a/libs/gtkmm2/gtk/gtkmm/toolbar.h
+++ b/libs/gtkmm2/gtk/gtkmm/toolbar.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TOOLBAR_H
 #define _GTKMM_TOOLBAR_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -93,20 +92,14 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_orientation_changed(Orientation orientation);
   virtual void on_toolbar_style_changed(ToolbarStyle style);
   virtual bool on_popup_context_menu(int x, int y, int button_number);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -119,7 +112,7 @@ public:
    * 0 the item is prepended to the start of the toolbar. If @a pos  is
    * negative, the item is appended to the end of the toolbar.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param item A Gtk::ToolItem.
    * @param pos The position of the new item.
    */
@@ -141,42 +134,40 @@ public:
    * @param item A Gtk::ToolItem that is a child of @a toolbar .
    * @return The position of item on the toolbar.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_item_index(const ToolItem& item) const;
   
   /** Returns the number of items on the toolbar.
    * @return The number of items on the toolbar
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_n_items() const;
   
-  /** Returns the @a n &lt;!-- --&gt;'th item on @a toolbar , or <tt>0</tt> if the
+  /** Returns the @a n &lt;!-- --&gt;'s item on @a toolbar , or <tt>0</tt> if the
    * toolbar does not contain an @a n &lt;!-- --&gt;'th item.
    * @param n A position on the toolbar.
    * @return The @a n &lt;!-- --&gt;'th Gtk::ToolItem on @a toolbar , or <tt>0</tt> if there
-   * isn't an @a n &lt;!-- --&gt;'th item.
+   * isn't an @a n &lt;!-- --&gt;th item.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   ToolItem* get_nth_item(int n);
   
-  /** Returns the @a n &lt;!-- --&gt;'th item on @a toolbar , or <tt>0</tt> if the
+  /** Returns the @a n &lt;!-- --&gt;'s item on @a toolbar , or <tt>0</tt> if the
    * toolbar does not contain an @a n &lt;!-- --&gt;'th item.
    * @param n A position on the toolbar.
    * @return The @a n &lt;!-- --&gt;'th Gtk::ToolItem on @a toolbar , or <tt>0</tt> if there
-   * isn't an @a n &lt;!-- --&gt;'th item.
+   * isn't an @a n &lt;!-- --&gt;th item.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const ToolItem* get_nth_item(int n) const;
   
   /** Returns whether the toolbar has an overflow menu.
-   * See set_show_arrow().
-   * @return <tt>true</tt> if the toolbar has an overflow menu.
-   * 
-   * @newin2p4.
+   * See set_show_arrow()
+   * @return Since: 2.4.
    */
   bool get_show_arrow() const;
   
@@ -185,7 +176,7 @@ public:
    * items that there are not room are available through an
    * overflow menu.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param show_arrow Whether to show an overflow menu.
    */
   void set_show_arrow(bool show_arrow = true);
@@ -234,7 +225,7 @@ public:
    */
   void unset_toolbar_style();
   
-  //Note that gtk_toolbar_set_icon_size() is deprecated, but gtk_toolbar_get_icon_size() is not.
+  //Note that gtk_toolbar_set_icon_size() is deprecated, bug gtk_toolbar_get_icon_size() is not.
   
   /** Retrieves the icon size fo the toolbar. See set_icon_size().
    * @return The current icon size for the icons on the toolbar.
@@ -246,7 +237,7 @@ public:
    * Gtk::Button::set_relief().
    * @return The relief style of buttons on @a toolbar .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   ReliefStyle get_relief_style() const;
   
@@ -260,7 +251,7 @@ public:
    * @param y Y coordinate of a point on the toolbar.
    * @return The position corresponding to the point ( @a x , @a y ) on the toolbar.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   int get_drop_index(int x, int y) const;
   
@@ -274,66 +265,27 @@ public:
    * added to any widget hierarchy or used as highlight item for another
    * toolbar.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param tool_item A Gtk::ToolItem, or <tt>0</tt> to turn of highlighting.
    * @param index A position on @a toolbar .
    */
   void set_drop_highlight_item(ToolItem& tool_item, int index);
   void unset_drop_highlight_item();
 
-  /** Emitted when the orientation of the toolbar changes.
-   *
-   * @param orientation The new Orientation of the toolbar.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>void %orientation_changed(Orientation orientation)</tt>
-   */
-
   Glib::SignalProxy1< void,Orientation > signal_orientation_changed();
 
   
-  /** Emitted when the style of the toolbar changes. 
-   * 
-   * @param @style The new ToolbarStyle of the toolbar.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %toolbar_style_changed(ToolbarStyle style)</tt>
-   */
-
   Glib::SignalProxy1< void,ToolbarStyle > signal_toolbar_style_changed();
 
   
-  /** Emitted when the user right-clicks the toolbar or uses the
-   * keybinding to display a popup menu.
-   *
-   * Application developers should handle this signal if they want
-   * to display a context menu on the toolbar. The context-menu should
-   * appear at the coordinates given by @a x and @a y. The mouse button
-   * number is given by the @a button parameter. If the menu was popped
-   * up using the keybaord, @a button is -1.
-   *
-   * @param x The x coordinate of the point where the menu should appear.
-   * @param y The y coordinate of the point where the menu should appear.
-   * @param button The mouse button the user pressed, or -1
-   * @resultt true if the signal was handled, false if not.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>bool %popup_context_menu(int x, int y, int button_number)</tt>
-   */
-
   Glib::SignalProxy3< bool,int,int,int > signal_popup_context_menu();
 
   
   //This is called get_tooltips_object() to avoid a clash with get_tooltips(), which just says whether they are enabled.
   
-   Tooltips* get_tooltips_object() const;
-   
+  Tooltips* get_tooltips_object() const;
+  
   //This is probably the same as Container::children().size(), which is deprecated anyway?
   //_MEMBER_GET(num_children, num_children, int, gint)
 
@@ -351,17 +303,14 @@ public:
   //but the GtkToolbar compatibility system is particularly unpleasant, so we just removed it in gtkmm 2.4. murrayc.
   
     
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The orientation of the toolbar.
+  /** The orientation of the toolbar.
    *
    * 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<Orientation> property_orientation() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The orientation of the toolbar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -369,19 +318,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Orientation> property_orientation() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** How to draw the toolbar.
+  /** How to draw the toolbar.
    *
    * 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<ToolbarStyle> property_toolbar_style() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** How to draw the toolbar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -389,19 +334,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ToolbarStyle> property_toolbar_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If an arrow should be shown if the toolbar doesn't fit.
+  /** If an arrow should be shown if the toolbar doesn't fit.
    *
    * 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_show_arrow() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If an arrow should be shown if the toolbar doesn't fit.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -409,7 +350,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_show_arrow() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -425,8 +365,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Toolbar* wrap(GtkToolbar* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TOOLBAR_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbutton.cc b/libs/gtkmm2/gtk/gtkmm/toolbutton.cc
index e0ec041c51..29519767d2 100644
--- a/libs/gtkmm2/gtk/gtkmm/toolbutton.cc
+++ b/libs/gtkmm2/gtk/gtkmm/toolbutton.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/toolbutton.h>
 #include <gtkmm/private/toolbutton_p.h>
 
@@ -44,15 +43,13 @@ ToolButton::ToolButton(const Glib::ustring& label)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo ToolButton_signal_clicked_info =
+const Glib::SignalProxyInfo ToolButton_signal_clicked_info =
 {
   "clicked",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -97,18 +94,10 @@ void ToolButton_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->clicked = &clicked_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void ToolButton_Class::clicked_callback(GtkToolButton* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -121,19 +110,15 @@ void ToolButton_Class::clicked_callback(GtkToolButton* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_clicked();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -146,7 +131,6 @@ void ToolButton_Class::clicked_callback(GtkToolButton* self)
       (*base->clicked)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ToolButton_Class::wrap_new(GObject* o)
@@ -211,7 +195,7 @@ ToolButton::ToolButton(Widget& icon_widget, const Glib::ustring& label)
 
 void ToolButton::set_label(const Glib::ustring& label)
 {
-gtk_tool_button_set_label(gobj(), label.c_str()); 
+  gtk_tool_button_set_label(gobj(), label.c_str());
 }
 
 Glib::ustring ToolButton::get_label() const
@@ -221,7 +205,7 @@ Glib::ustring ToolButton::get_label() const
 
 void ToolButton::set_use_underline(bool use_underline)
 {
-gtk_tool_button_set_use_underline(gobj(), static_cast<int>(use_underline)); 
+  gtk_tool_button_set_use_underline(gobj(), static_cast<int>(use_underline));
 }
 
 bool ToolButton::get_use_underline() const
@@ -231,7 +215,7 @@ bool ToolButton::get_use_underline() const
 
 void ToolButton::set_stock_id(const Gtk::StockID& stock_id)
 {
-gtk_tool_button_set_stock_id(gobj(), (stock_id).get_c_str()); 
+  gtk_tool_button_set_stock_id(gobj(), (stock_id).get_c_str());
 }
 
 Glib::ustring ToolButton::get_stock_id() const
@@ -239,19 +223,9 @@ Glib::ustring ToolButton::get_stock_id() const
   return Glib::convert_const_gchar_ptr_to_ustring(gtk_tool_button_get_stock_id(const_cast<GtkToolButton*>(gobj())));
 }
 
-void ToolButton::set_icon_name(const Glib::ustring& icon_name)
-{
-gtk_tool_button_set_icon_name(gobj(), icon_name.c_str()); 
-}
-
-Glib::ustring ToolButton::get_icon_name() const
-{
-  return Glib::convert_const_gchar_ptr_to_ustring(gtk_tool_button_get_icon_name(const_cast<GtkToolButton*>(gobj())));
-}
-
 void ToolButton::set_icon_widget(Widget& icon_widget)
 {
-gtk_tool_button_set_icon_widget(gobj(), (icon_widget).gobj()); 
+  gtk_tool_button_set_icon_widget(gobj(), (icon_widget).gobj());
 }
 
 Widget* ToolButton::get_icon_widget()
@@ -261,12 +235,12 @@ Widget* ToolButton::get_icon_widget()
 
 const Widget* ToolButton::get_icon_widget() const
 {
-  return const_cast<ToolButton*>(this)->get_icon_widget();
+  return Glib::wrap(gtk_tool_button_get_icon_widget(const_cast<GtkToolButton*>(gobj())));
 }
 
 void ToolButton::set_label_widget(Widget& label_widget)
 {
-gtk_tool_button_set_label_widget(gobj(), (label_widget).gobj()); 
+  gtk_tool_button_set_label_widget(gobj(), (label_widget).gobj());
 }
 
 Widget* ToolButton::get_label_widget()
@@ -276,7 +250,7 @@ Widget* ToolButton::get_label_widget()
 
 const Widget* ToolButton::get_label_widget() const
 {
-  return const_cast<ToolButton*>(this)->get_label_widget();
+  return Glib::wrap(gtk_tool_button_get_label_widget(const_cast<GtkToolButton*>(gobj())));
 }
 
 
@@ -286,78 +260,57 @@ Glib::SignalProxy0< void > ToolButton::signal_clicked()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> ToolButton::property_label() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> ToolButton::property_label() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "label");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToolButton::property_use_underline() 
 {
   return Glib::PropertyProxy<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToolButton::property_use_underline() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "use-underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Widget*> ToolButton::property_label_widget() 
 {
   return Glib::PropertyProxy<Gtk::Widget*>(this, "label-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Widget*> ToolButton::property_label_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "label-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> ToolButton::property_stock_id() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "stock-id");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> ToolButton::property_stock_id() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "stock-id");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Widget> ToolButton::property_icon_widget() 
 {
   return Glib::PropertyProxy<Gtk::Widget>(this, "icon-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Widget> ToolButton::property_icon_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Widget>(this, "icon-widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::ToolButton::on_clicked()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -367,10 +320,6 @@ void Gtk::ToolButton::on_clicked()
   if(base && base->clicked)
     (*base->clicked)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/toolbutton.h b/libs/gtkmm2/gtk/gtkmm/toolbutton.h
index d023ac564f..c4a2622b95 100644
--- a/libs/gtkmm2/gtk/gtkmm/toolbutton.h
+++ b/libs/gtkmm2/gtk/gtkmm/toolbutton.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TOOLBUTTON_H
 #define _GTKMM_TOOLBUTTON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -90,18 +89,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_clicked();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -111,7 +104,7 @@ public:
   /** Creates a new ToolButton.
    */
   ToolButton();
- 
+  
   /** Creates a new ToolButton from a StockID.
    *
    * The ToolButton will be created according to the @a stock_id properties.
@@ -119,7 +112,7 @@ public:
    * @param stock_id The StockID which determines the look of the ToolButton.
    */
   explicit ToolButton(const Gtk::StockID& stock_id);
-
+  
   /** Creates a new ToolButton with a label.
    *
    * The ToolButton will have the label @a label.
@@ -127,7 +120,7 @@ public:
    * @param label The string used to display the label for this ToolButton.
    */
   explicit ToolButton(const Glib::ustring& label);
-
+  
   /** Creates a new ToolButton with an image.
    *
    * The ToolButton will have the label @a label and an image widget @a icon_widget.
@@ -144,7 +137,7 @@ public:
    * is determined by the "stock_id" property. If the "stock_id" property is also
    * <tt>0</tt>, @a button  will not have a label.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param label A string that will be used as label, or <tt>0</tt>.
    */
   void set_label(const Glib::ustring& label);
@@ -154,7 +147,7 @@ public:
    * string is owned by GTK+, and must not be modified or freed.
    * @return The label, or <tt>0</tt>
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_label() const;
   
@@ -167,7 +160,7 @@ public:
    * Labels shown on tool buttons never have mnemonics on them; this property
    * only affects the menu item on the overflow menu.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_underline Whether the button label has the form "_Open".
    */
   void set_use_underline(bool use_underline = true);
@@ -177,15 +170,15 @@ public:
    * @return <tt>true</tt> if underscores in the label property are used as
    * mnemonics on menu items on the overflow menu.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_use_underline() const;
   
-  /** Sets the name of the stock item. See the ToolButton::ToolButton(const Gtk::StockID& stock_id, IconSize size) constructor.
-   *     The stock_id property only has an effect if not
-   *     overridden by "label" and "icon_widget" properties.
+  /** Sets the name of the stock item. See new_from_stock().
+   * The stock_id property only has an effect if not
+   * overridden by non-<tt>0</tt> "label" and "icon_widget" properties.
    * 
-   *     @a newin2p4 
+   * Since: 2.4
    * @param stock_id A name of a stock item, or <tt>0</tt>.
    */
   void set_stock_id(const Gtk::StockID& stock_id);
@@ -194,35 +187,15 @@ public:
    * The returned string is owned by GTK+ and must not be freed or modifed.
    * @return The name of the stock item for @a button .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_stock_id() const;
   
-  /** Sets the icon for the tool button from a named themed icon.
-   * See the docs for Gtk::IconTheme for more details.
-   * The "icon_name" property only has an effect if not
-   * overridden by non-<tt>0</tt> "label", "icon_widget" and "stock_id"
-   * properties.
-   * 
-   * @newin2p8
-   * @param icon_name The name of the themed icon.
-   */
-  void set_icon_name(const Glib::ustring& icon_name);
-  
-  /** Returns the name of the themed icon for the tool button,
-   * see set_icon_name().
-   * @return The icon name or <tt>0</tt> if the tool button has
-   * no themed icon
-   * 
-   * @newin2p8.
-   */
-  Glib::ustring get_icon_name() const;
-  
   /** Sets @a icon  as the widget used as icon on @a button . If @a icon_widget  is
    * <tt>0</tt> the icon is determined by the "stock_id" property. If the
    * "stock_id" property is also <tt>0</tt>, @a button  will not have an icon.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param icon_widget The widget used as icon, or <tt>0</tt>.
    */
   void set_icon_widget(Widget& icon_widget);
@@ -231,7 +204,7 @@ public:
    * set_icon_widget().
    * @return The widget used as icon on @a button , or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* get_icon_widget();
   
@@ -239,7 +212,7 @@ public:
    * set_icon_widget().
    * @return The widget used as icon on @a button , or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* get_icon_widget() const;
   
@@ -249,7 +222,7 @@ public:
    * determined by the "stock_id" property is used as label. If
    * "stock_id" is also <tt>0</tt>, @a button  does not have a label.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param label_widget The widget used as label, or <tt>0</tt>.
    */
   void set_label_widget(Widget& label_widget);
@@ -258,7 +231,7 @@ public:
    * set_label_widget().
    * @return The widget used as label on @a button , or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* get_label_widget();
   
@@ -266,34 +239,22 @@ public:
    * set_label_widget().
    * @return The widget used as label on @a button , or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* get_label_widget() const;
 
- /** This signal is emitted when the tool button is clicked with the mouse
-  * or activated with the keyboard.
-  * @deprecated This is an "action" key-binding signal that you should rarely need to use.
-  */
   
-/**
-   * @par Prototype:
-   * <tt>void %clicked()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_clicked();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text to show in the item.
+  /** Text to show in the item.
    *
    * 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_label() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Text to show in the item.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -301,19 +262,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_label() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If set
+  /** If 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<bool> property_use_underline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If set
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -321,19 +278,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_use_underline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Widget to use as the item label.
+  /** Widget to use as the item label.
    *
    * 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_label_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Widget to use as the item label.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -341,19 +294,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_label_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The stock icon displayed on the item.
+  /** The stock icon displayed on the item.
    *
    * 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_stock_id() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The stock icon displayed on the item.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -361,19 +310,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_stock_id() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Icon widget to display in the item.
+  /** Icon widget to display in the item.
    *
    * 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_icon_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Icon widget to display in the item.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -381,7 +326,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Widget> property_icon_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
               
 
 };
@@ -397,8 +341,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ToolButton* wrap(GtkToolButton* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TOOLBUTTON_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/toolitem.cc b/libs/gtkmm2/gtk/gtkmm/toolitem.cc
index ed0936164c..bc9e5dbc98 100644
--- a/libs/gtkmm2/gtk/gtkmm/toolitem.cc
+++ b/libs/gtkmm2/gtk/gtkmm/toolitem.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/toolitem.h>
 #include <gtkmm/private/toolitem_p.h>
 
@@ -38,8 +37,7 @@ namespace Gtk
 namespace
 {
 
-
-static gboolean ToolItem_signal_create_menu_proxy_callback(GtkToolItem* self, void* data)
+gboolean ToolItem_signal_create_menu_proxy_callback(GtkToolItem* self, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool > SlotType;
@@ -47,26 +45,22 @@ static gboolean ToolItem_signal_create_menu_proxy_callback(GtkToolItem* self, vo
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean ToolItem_signal_create_menu_proxy_notify_callback(GtkToolItem* self,  void* data)
+gboolean ToolItem_signal_create_menu_proxy_notify_callback(GtkToolItem* self,  void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void > SlotType;
@@ -74,26 +68,22 @@ static gboolean ToolItem_signal_create_menu_proxy_notify_callback(GtkToolItem* s
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo ToolItem_signal_create_menu_proxy_info =
+const Glib::SignalProxyInfo ToolItem_signal_create_menu_proxy_info =
 {
   "create_menu_proxy",
   (GCallback) &ToolItem_signal_create_menu_proxy_callback,
@@ -101,7 +91,7 @@ static const Glib::SignalProxyInfo ToolItem_signal_create_menu_proxy_info =
 };
 
 
-static const Glib::SignalProxyInfo ToolItem_signal_toolbar_reconfigured_info =
+const Glib::SignalProxyInfo ToolItem_signal_toolbar_reconfigured_info =
 {
   "toolbar_reconfigured",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -109,7 +99,7 @@ static const Glib::SignalProxyInfo ToolItem_signal_toolbar_reconfigured_info =
 };
 
 
-static gboolean ToolItem_signal_set_tooltip_callback(GtkToolItem* self, GtkTooltips* p0,const gchar* p1,const gchar* p2,void* data)
+gboolean ToolItem_signal_set_tooltip_callback(GtkToolItem* self, GtkTooltips* p0,const gchar* p1,const gchar* p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& > SlotType;
@@ -117,29 +107,25 @@ static gboolean ToolItem_signal_set_tooltip_callback(GtkToolItem* self, GtkToolt
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::convert_const_gchar_ptr_to_ustring(p1)
 , Glib::convert_const_gchar_ptr_to_ustring(p2)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean ToolItem_signal_set_tooltip_notify_callback(GtkToolItem* self, GtkTooltips* p0,const gchar* p1,const gchar* p2, void* data)
+gboolean ToolItem_signal_set_tooltip_notify_callback(GtkToolItem* self, GtkTooltips* p0,const gchar* p1,const gchar* p2, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Tooltips*,const Glib::ustring&,const Glib::ustring& > SlotType;
@@ -147,36 +133,31 @@ static gboolean ToolItem_signal_set_tooltip_notify_callback(GtkToolItem* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::convert_const_gchar_ptr_to_ustring(p1)
 , Glib::convert_const_gchar_ptr_to_ustring(p2)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo ToolItem_signal_set_tooltip_info =
+const Glib::SignalProxyInfo ToolItem_signal_set_tooltip_info =
 {
   "set_tooltip",
   (GCallback) &ToolItem_signal_set_tooltip_callback,
   (GCallback) &ToolItem_signal_set_tooltip_notify_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -221,19 +202,11 @@ void ToolItem_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->create_menu_proxy = &create_menu_proxy_callback;
   klass->toolbar_reconfigured = &toolbar_reconfigured_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 gboolean ToolItem_Class::create_menu_proxy_callback(GtkToolItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -246,19 +219,15 @@ gboolean ToolItem_Class::create_menu_proxy_callback(GtkToolItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_create_menu_proxy());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -274,6 +243,7 @@ gboolean ToolItem_Class::create_menu_proxy_callback(GtkToolItem* self)
   typedef gboolean RType;
   return RType();
 }
+
 void ToolItem_Class::toolbar_reconfigured_callback(GtkToolItem* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -286,19 +256,15 @@ void ToolItem_Class::toolbar_reconfigured_callback(GtkToolItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_toolbar_reconfigured();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -311,7 +277,6 @@ void ToolItem_Class::toolbar_reconfigured_callback(GtkToolItem* self)
       (*base->toolbar_reconfigured)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* ToolItem_Class::wrap_new(GObject* o)
@@ -362,7 +327,7 @@ ToolItem::ToolItem()
 
 void ToolItem::set_homogeneous(bool homogeneous)
 {
-gtk_tool_item_set_homogeneous(gobj(), static_cast<int>(homogeneous)); 
+  gtk_tool_item_set_homogeneous(gobj(), static_cast<int>(homogeneous));
 }
 
 bool ToolItem::get_homogeneous() const
@@ -372,7 +337,7 @@ bool ToolItem::get_homogeneous() const
 
 void ToolItem::set_expand(bool expand)
 {
-gtk_tool_item_set_expand(gobj(), static_cast<int>(expand)); 
+  gtk_tool_item_set_expand(gobj(), static_cast<int>(expand));
 }
 
 bool ToolItem::get_expand() const
@@ -382,12 +347,12 @@ bool ToolItem::get_expand() const
 
 void ToolItem::set_tooltip(Tooltips& tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private)
 {
-gtk_tool_item_set_tooltip(gobj(), (tooltips).gobj(), tip_text.c_str(), tip_private.c_str()); 
+  gtk_tool_item_set_tooltip(gobj(), (tooltips).gobj(), tip_text.c_str(), tip_private.c_str());
 }
 
 void ToolItem::set_use_drag_window(bool use_drag_window)
 {
-gtk_tool_item_set_use_drag_window(gobj(), static_cast<int>(use_drag_window)); 
+  gtk_tool_item_set_use_drag_window(gobj(), static_cast<int>(use_drag_window));
 }
 
 bool ToolItem::get_use_drag_window() const
@@ -397,7 +362,7 @@ bool ToolItem::get_use_drag_window() const
 
 void ToolItem::set_visible_horizontal(bool visible_horizontal)
 {
-gtk_tool_item_set_visible_horizontal(gobj(), static_cast<int>(visible_horizontal)); 
+  gtk_tool_item_set_visible_horizontal(gobj(), static_cast<int>(visible_horizontal));
 }
 
 bool ToolItem::get_visible_horizontal() const
@@ -407,7 +372,7 @@ bool ToolItem::get_visible_horizontal() const
 
 void ToolItem::set_visible_vertical(bool visible_vertical)
 {
-gtk_tool_item_set_visible_vertical(gobj(), static_cast<int>(visible_vertical)); 
+  gtk_tool_item_set_visible_vertical(gobj(), static_cast<int>(visible_vertical));
 }
 
 bool ToolItem::get_visible_vertical() const
@@ -422,7 +387,7 @@ bool ToolItem::get_is_important() const
 
 void ToolItem::set_is_important(bool is_important)
 {
-gtk_tool_item_set_is_important(gobj(), static_cast<int>(is_important)); 
+  gtk_tool_item_set_is_important(gobj(), static_cast<int>(is_important));
 }
 
 IconSize ToolItem::get_icon_size() const
@@ -452,7 +417,7 @@ Widget* ToolItem::retrieve_proxy_menu_item()
 
 const Widget* ToolItem::retrieve_proxy_menu_item() const
 {
-  return const_cast<ToolItem*>(this)->retrieve_proxy_menu_item();
+  return Glib::wrap(gtk_tool_item_retrieve_proxy_menu_item(const_cast<GtkToolItem*>(gobj())));
 }
 
 Widget* ToolItem::get_proxy_menu_item(const Glib::ustring& menu_item_id)
@@ -462,17 +427,17 @@ Widget* ToolItem::get_proxy_menu_item(const Glib::ustring& menu_item_id)
 
 const Widget* ToolItem::get_proxy_menu_item(const Glib::ustring& menu_item_id) const
 {
-  return const_cast<ToolItem*>(this)->get_proxy_menu_item(menu_item_id);
+  return Glib::wrap(gtk_tool_item_get_proxy_menu_item(const_cast<GtkToolItem*>(gobj()), menu_item_id.c_str()));
 }
 
 void ToolItem::set_proxy_menu_item(const Glib::ustring& menu_item_id, Widget& menu_item)
 {
-gtk_tool_item_set_proxy_menu_item(gobj(), menu_item_id.c_str(), (menu_item).gobj()); 
+  gtk_tool_item_set_proxy_menu_item(gobj(), menu_item_id.c_str(), (menu_item).gobj());
 }
 
 void ToolItem::rebuild_menu()
 {
-gtk_tool_item_rebuild_menu(gobj()); 
+  gtk_tool_item_rebuild_menu(gobj());
 }
 
 
@@ -481,63 +446,48 @@ Glib::SignalProxy0< bool > ToolItem::signal_create_menu_proxy()
   return Glib::SignalProxy0< bool >(this, &ToolItem_signal_create_menu_proxy_info);
 }
 
-
 Glib::SignalProxy0< void > ToolItem::signal_toolbar_reconfigured()
 {
   return Glib::SignalProxy0< void >(this, &ToolItem_signal_toolbar_reconfigured_info);
 }
 
-
 Glib::SignalProxy3< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& > ToolItem::signal_set_tooltip()
 {
   return Glib::SignalProxy3< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& >(this, &ToolItem_signal_set_tooltip_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToolItem::property_visible_horizontal() 
 {
   return Glib::PropertyProxy<bool>(this, "visible-horizontal");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToolItem::property_visible_horizontal() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-horizontal");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToolItem::property_visible_vertical() 
 {
   return Glib::PropertyProxy<bool>(this, "visible-vertical");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToolItem::property_visible_vertical() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible-vertical");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> ToolItem::property_is_important() 
 {
   return Glib::PropertyProxy<bool>(this, "is-important");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> ToolItem::property_is_important() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "is-important");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 bool Gtk::ToolItem::on_create_menu_proxy()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -550,6 +500,7 @@ bool Gtk::ToolItem::on_create_menu_proxy()
   typedef bool RType;
   return RType();
 }
+
 void Gtk::ToolItem::on_toolbar_reconfigured()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -559,10 +510,6 @@ void Gtk::ToolItem::on_toolbar_reconfigured()
   if(base && base->toolbar_reconfigured)
     (*base->toolbar_reconfigured)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/toolitem.h b/libs/gtkmm2/gtk/gtkmm/toolitem.h
index 043d59eb58..29b4bf2850 100644
--- a/libs/gtkmm2/gtk/gtkmm/toolitem.h
+++ b/libs/gtkmm2/gtk/gtkmm/toolitem.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TOOLITEM_H
 #define _GTKMM_TOOLITEM_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -90,19 +89,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual bool on_create_menu_proxy();
   virtual void on_toolbar_reconfigured();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -115,7 +108,7 @@ public:
    * homogeneous items. The effect is that all homogeneous items will have
    * the same width as the widest of the items.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param homogeneous Whether @a tool_item  is the same size as other homogeneous items.
    */
   void set_homogeneous(bool homogeneous = true);
@@ -125,7 +118,7 @@ public:
    * @return <tt>true</tt> if the item is the same size as other homogeneous
    * item.s
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_homogeneous() const;
 
@@ -135,7 +128,7 @@ public:
    * effect is that the item gets bigger when the toolbar gets bigger
    * and smaller when the toolbar gets smaller.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param expand Whether @a tool_item  is allocated extra space.
    */
   void set_expand(bool expand = true);
@@ -144,7 +137,7 @@ public:
    * See set_expand().
    * @return <tt>true</tt> if @a tool_item  is allocated extra space.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_expand() const;
 
@@ -153,7 +146,7 @@ public:
    * text to be displayed as tooltip on the item and the private text
    * to be used. See Gtk::Tooltips::set_tip().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param tooltips The Gtk::Tooltips object to be used.
    * @param tip_text Text to be used as tooltip text for @a tool_item .
    * @param tip_private Text to be used as private tooltip text.
@@ -166,7 +159,7 @@ public:
    * When @a toolitem  has a drag window it will intercept all events,
    * even those that would otherwise be sent to a child of @a toolitem .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param use_drag_window Whether @a toolitem  has a drag window.
    */
   void set_use_drag_window(bool use_drag_window = true);
@@ -175,14 +168,14 @@ public:
    * set_use_drag_window().
    * @return <tt>true</tt> if @a toolitem  uses a drag window.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_use_drag_window() const;
 
   
   /** Sets whether @a toolitem  is visible when the toolbar is docked horizontally.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param visible_horizontal Whether @a toolitem  is visible when in horizontal mode.
    */
   void set_visible_horizontal(bool visible_horizontal = true);
@@ -192,7 +185,7 @@ public:
    * @return <tt>true</tt> if @a toolitem  is visible on toolbars that are
    * docked horizontally.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_visible_horizontal() const;
 
@@ -202,7 +195,7 @@ public:
    * useful on a vertically docked toolbar. If @a visible_vertical  is <tt>false</tt>
    *  @a toolitem  will not appear on toolbars that are docked vertically.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param visible_vertical Whether @a toolitem  is visible when the toolbar
    * is in vertical mode.
    */
@@ -212,7 +205,7 @@ public:
    * See set_visible_vertical().
    * @return Whether @a toolitem  is visible when the toolbar is docked vertically
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_visible_vertical() const;
 
@@ -221,7 +214,7 @@ public:
    * set_is_important()
    * @return <tt>true</tt> if @a tool_item  is considered important.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_is_important() const;
   
@@ -231,7 +224,7 @@ public:
    * only tool buttons with the "is_important" property set have labels, an
    * effect known as "priority text"
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param is_important Whether the tool item should be considered important.
    */
   void set_is_important(bool is_important = true);
@@ -242,7 +235,7 @@ public:
    * they should use.
    * @return A Gtk::IconSize indicating the icon size used for @a tool_item 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   IconSize get_icon_size () const;
   
@@ -252,7 +245,7 @@ public:
    * @return A Gtk::Orientation indicating the orientation
    * used for @a tool_item 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Orientation get_orientation() const;
   
@@ -278,7 +271,7 @@ public:
    * @return A Gtk::ToolbarStyle indicating the toolbar style used
    * for @a tool_item .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   ToolbarStyle get_toolbar_style() const;
   
@@ -289,7 +282,7 @@ public:
    * @return A Gtk::ReliefStyle indicating the relief style used
    * for @a tool_item .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   ReliefStyle get_relief_style() const;
 
@@ -300,7 +293,7 @@ public:
    * @return The Gtk::MenuItem that is going to appear in the
    * overflow menu for @a tool_item .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* retrieve_proxy_menu_item();
   
@@ -310,7 +303,7 @@ public:
    * @return The Gtk::MenuItem that is going to appear in the
    * overflow menu for @a tool_item .
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* retrieve_proxy_menu_item() const;
   
@@ -325,7 +318,7 @@ public:
    * @return The Gtk::MenuItem passed to
    * set_proxy_menu_item(), if the @a menu_item_id &lt;!-- --&gt;s match.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* get_proxy_menu_item(const Glib::ustring& menu_item_id);
   
@@ -340,7 +333,7 @@ public:
    * @return The Gtk::MenuItem passed to
    * set_proxy_menu_item(), if the @a menu_item_id &lt;!-- --&gt;s match.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* get_proxy_menu_item(const Glib::ustring& menu_item_id) const;
   
@@ -348,7 +341,7 @@ public:
    *  @a menu_item_id  is used to identify the caller of this function and
    * should also be used with get_proxy_menu_item().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param menu_item_id A string used to identify @a menu_item .
    * @param menu_item A Gtk::MenuItem to be used in the overflow menu.
    */
@@ -364,97 +357,32 @@ public:
    * changes what it will do in response to the "create_menu_proxy"
    * signal.
    * 
-   * @newin2p6
+   * Since: 2.6
    */
   void rebuild_menu();
   
-  //TODO: This suggests calling set_proxy_menu_item() with NULL. but the function asserts against that.
-  /** This signal is emitted when the toolbar needs information from @tool_item
-   * about whether the item should appear in the toolbar overflow menu. In
-   * response the tool item should either
-   * <itemizedlist>
-   * <listitem> call set_proxy_menu_item() with a NULL
-   * pointer and return true to indicate that the item should not appear
-   * in the overflow menu
-   * </listitem>
-   * <listitem> call set_proxy_menu_item() with a new menu
-   * item and return true, or 
-   * </listitem>
-   * <listitem> return false to indicate that the signal was not
-   * handled by the item. This means that
-   * the item will not appear in the overflow menu unless a later handler
-   * installs a menu item.
-   * </listitem>
-   * </itemizedlist>
-   *
-   * The toolbar may cache the result of this signal. When the tool item changes
-   * how it will respond to this signal it must call rebuild_menu()
-   * to invalidate the cache and ensure that the toolbar rebuilds its overflow
-   * menu.
-   *
-   * @result true if the signal was handled, false if not
-   */
   
-/**
-   * @par Prototype:
-   * <tt>bool %create_menu_proxy()</tt>
-   */
-
   Glib::SignalProxy0< bool > signal_create_menu_proxy();
 
   
-  /** This signal is emitted when some property of the toolbar that the
-   * item is a child of changes. For custom subclasses of ToolItem,
-   * the default handler of this signal use the functions
-   * <itemizedlist>
-   * <listitem>Toolbar::get_orientation()</listitem>
-   * <listitem>Toolbar::get_style()</listitem>
-   * <listitem>Toolbar::get_icon_size()</listitem>
-   * <listitem>Toolbar::get_relief_style()</listitem>
-   * </itemizedlist>
-   * to find out what the toolbar should look like and change
-   * themselves accordingly.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %toolbar_reconfigured()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_toolbar_reconfigured();
 
 
   //We use no_default_handler for this, because we can not add a new vfunc to 2.5 without breaking ABI.
   //TODO: Remove no_default_handler when we do an ABI-break-with-parallel-install.
-  /** This signal is emitted when the toolitem's tooltip changes.
-   * Application developers can use gtk_tool_item_set_tooltip() to
-   * set the item's tooltip.
-   *
-   * @param tooltips the Tooltips
-   * @param tip_text the tooltip text
-   * @param tip_private the tooltip private text
-   * @result true if the signal was handled, false if not.
-   */
   
-/**
-   * @par Prototype:
-   * <tt>bool %set_tooltip(Tooltips* tooltips, const Glib::ustring& tip_text, const Glib::ustring& tip_private)</tt>
-   */
 
   Glib::SignalProxy3< bool,Tooltips*,const Glib::ustring&,const Glib::ustring& > signal_set_tooltip();
 
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+  /** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
    *
    * 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_horizontal() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -462,19 +390,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible_horizontal() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+  /** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
    *
    * 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_vertical() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the toolbar item is visible when the toolbar is in a vertical orientation.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -482,19 +406,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible_vertical() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the toolbar item is considered important. When TRUE
+  /** Whether the toolbar item is considered important. When TRUE
    *
    * 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_is_important() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the toolbar item is considered important. When TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -502,7 +422,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_is_important() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -518,8 +437,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::ToolItem* wrap(GtkToolItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TOOLITEM_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/tooltips.cc b/libs/gtkmm2/gtk/gtkmm/tooltips.cc
index ad6a0b78bb..80b1946879 100644
--- a/libs/gtkmm2/gtk/gtkmm/tooltips.cc
+++ b/libs/gtkmm2/gtk/gtkmm/tooltips.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/tooltips.h>
 #include <gtkmm/private/tooltips_p.h>
 
@@ -92,19 +91,8 @@ void Tooltips_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Tooltips_Class::wrap_new(GObject* o)
 {
@@ -154,17 +142,17 @@ Tooltips::Tooltips()
 
 void Tooltips::enable()
 {
-gtk_tooltips_enable(gobj()); 
+  gtk_tooltips_enable(gobj());
 }
 
 void Tooltips::disable()
 {
-gtk_tooltips_disable(gobj()); 
+  gtk_tooltips_disable(gobj());
 }
 
 void Tooltips::set_tip(Widget& widget, const Glib::ustring& tip_text, const Glib::ustring& tip_private)
 {
-gtk_tooltips_set_tip(gobj(), (widget).gobj(), tip_text.c_str(), tip_private.c_str()); 
+  gtk_tooltips_set_tip(gobj(), (widget).gobj(), tip_text.c_str(), tip_private.c_str());
 }
 
 GtkTooltipsData* Tooltips::data_get(Widget& widget)
@@ -172,20 +160,12 @@ GtkTooltipsData* Tooltips::data_get(Widget& widget)
   return gtk_tooltips_data_get((widget).gobj());
 }
 
-
 void Tooltips::force_window()
 {
-gtk_tooltips_force_window(gobj()); 
+  gtk_tooltips_force_window(gobj());
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/tooltips.h b/libs/gtkmm2/gtk/gtkmm/tooltips.h
index 4e1614d6cc..277dc72466 100644
--- a/libs/gtkmm2/gtk/gtkmm/tooltips.h
+++ b/libs/gtkmm2/gtk/gtkmm/tooltips.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TOOLTIPS_H
 #define _GTKMM_TOOLTIPS_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,17 +95,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -147,8 +140,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Tooltips* wrap(GtkTooltips* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TOOLTIPS_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragdest.cc b/libs/gtkmm2/gtk/gtkmm/treedragdest.cc
index e899e90376..d201fbddea 100644
--- a/libs/gtkmm2/gtk/gtkmm/treedragdest.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treedragdest.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treedragdest.h>
 #include <gtkmm/private/treedragdest_p.h>
 
@@ -75,16 +74,10 @@ void TreeDragDest_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->drag_data_received = &drag_data_received_vfunc_callback;
   klass->row_drop_possible = &row_drop_possible_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gboolean TreeDragDest_Class::drag_data_received_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest, GtkSelectionData* selection_data)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -97,21 +90,17 @@ gboolean TreeDragDest_Class::drag_data_received_vfunc_callback(GtkTreeDragDest*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->drag_data_received_vfunc(Gtk::TreePath(dest, true)
 , SelectionData_WithoutOwnership(selection_data)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -128,6 +117,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean TreeDragDest_Class::row_drop_possible_vfunc_callback(GtkTreeDragDest* self, GtkTreePath* dest_path, GtkSelectionData* selection_data)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -140,21 +130,17 @@ gboolean TreeDragDest_Class::row_drop_possible_vfunc_callback(GtkTreeDragDest* s
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->row_drop_possible_vfunc(Gtk::TreePath(dest_path, true)
 , SelectionData_WithoutOwnership(selection_data)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -171,10 +157,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TreeDragDest_Class::wrap_new(GObject* object)
@@ -228,10 +210,6 @@ bool TreeDragDest::row_drop_possible(const TreeModel::Path& dest_path, const Sel
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 bool Gtk::TreeDragDest::drag_data_received_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -245,6 +223,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::TreeDragDest::row_drop_possible_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -258,7 +237,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragdest.h b/libs/gtkmm2/gtk/gtkmm/treedragdest.h
index 59b4a8376b..afd98c697c 100644
--- a/libs/gtkmm2/gtk/gtkmm/treedragdest.h
+++ b/libs/gtkmm2/gtk/gtkmm/treedragdest.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEDRAGDEST_H
 #define _GTKMM_TREEDRAGDEST_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -126,31 +125,20 @@ public:
   bool row_drop_possible(const TreeModel::Path& dest_path, const SelectionData& selection_data) const;
                              
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool drag_data_received_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual bool drag_data_received_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data);
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool row_drop_possible_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data) const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual bool row_drop_possible_vfunc(const TreeModel::Path& dest, const SelectionData& selection_data) const;
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -169,6 +157,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TREEDRAGDEST_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragsource.cc b/libs/gtkmm2/gtk/gtkmm/treedragsource.cc
index 28bb5b1a39..57cbdeb64b 100644
--- a/libs/gtkmm2/gtk/gtkmm/treedragsource.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treedragsource.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treedragsource.h>
 #include <gtkmm/private/treedragsource_p.h>
 
@@ -32,7 +31,6 @@
 namespace Gtk
 {
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 //This vfunc wrapper is manually written, so that we can use a temporary instance for the SelectionData& output parameter:
 
 gboolean TreeDragSource_Class::drag_data_get_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path, GtkSelectionData* selection_data)
@@ -47,20 +45,16 @@ gboolean TreeDragSource_Class::drag_data_get_vfunc_callback(GtkTreeDragSource* s
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       SelectionData_WithoutOwnership temp_instance(selection_data);
       return static_cast<int>(obj->drag_data_get_vfunc(Gtk::TreePath(path, true), temp_instance));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -91,7 +85,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 } //namespace Gtk
 
@@ -142,17 +135,11 @@ void TreeDragSource_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
     klass->drag_data_get = &drag_data_get_vfunc_callback;
     klass->row_draggable = &row_draggable_vfunc_callback;
   klass->drag_data_delete = &drag_data_delete_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gboolean TreeDragSource_Class::row_draggable_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -165,20 +152,16 @@ gboolean TreeDragSource_Class::row_draggable_vfunc_callback(GtkTreeDragSource* s
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->row_draggable_vfunc(Gtk::TreePath(path, true)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -195,6 +178,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 gboolean TreeDragSource_Class::drag_data_delete_vfunc_callback(GtkTreeDragSource* self, GtkTreePath* path)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -207,20 +191,16 @@ gboolean TreeDragSource_Class::drag_data_delete_vfunc_callback(GtkTreeDragSource
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->drag_data_delete_vfunc(Gtk::TreePath(path, true)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -237,10 +217,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TreeDragSource_Class::wrap_new(GObject* object)
@@ -299,10 +275,6 @@ bool TreeDragSource::drag_data_delete(const TreeModel::Path& path)
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
 bool Gtk::TreeDragSource::row_draggable_vfunc(const TreeModel::Path& path) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -316,6 +288,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::TreeDragSource::drag_data_delete_vfunc(const TreeModel::Path& path) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -329,7 +302,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/treedragsource.h b/libs/gtkmm2/gtk/gtkmm/treedragsource.h
index 9887fcd00c..41bdf732ec 100644
--- a/libs/gtkmm2/gtk/gtkmm/treedragsource.h
+++ b/libs/gtkmm2/gtk/gtkmm/treedragsource.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEDRAGSOURCE_H
 #define _GTKMM_TREEDRAGSOURCE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -133,36 +132,23 @@ public:
 protected:
 
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool row_draggable_vfunc(const TreeModel::Path& path) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual bool row_draggable_vfunc(const TreeModel::Path& path) const;
 
-  //We hand-code this so that we can use a temporary instance for the SelectionData& output parameter:
-  #ifdef GLIBMM_VFUNCS_ENABLED
+  //We hand-code this so that we can use a temporary instance for teh SelectionData& output parameter:
   virtual bool drag_data_get_vfunc(const TreeModel::Path& path, SelectionData& selection_data) const;
-  #endif //GLIBMM_VFUNCS_ENABLED
    
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool drag_data_delete_vfunc(const TreeModel::Path& path);
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual bool drag_data_delete_vfunc(const TreeModel::Path& path);
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -181,6 +167,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TREEDRAGSOURCE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treeiter.cc b/libs/gtkmm2/gtk/gtkmm/treeiter.cc
index 4addfcc9b4..8c355c353d 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeiter.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treeiter.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treeiter.h>
 #include <gtkmm/private/treeiter_p.h>
 
@@ -30,7 +29,7 @@ namespace
 {
 
 // This is copied from Totem. In future there might be a version in GTK+ itself - see bug #
-static void gtkmm_gtk_tree_model_iter_previous(GtkTreeModel* tree_model, GtkTreeIter* iter)
+void gtkmm_gtk_tree_model_iter_previous(GtkTreeModel* tree_model, GtkTreeIter* iter)
 {
   GtkTreePath *const path = gtk_tree_model_get_path(tree_model, iter);
 
@@ -151,6 +150,8 @@ bool TreeIter::equal(const TreeIter& other) const
   // A GtkTreeIter has the same stamp value as its model.
   g_assert(gobject_.stamp == other.gobject_.stamp || is_end_ || other.is_end_);
 
+  //TODO: Allow custom treemodels to provide a different implementation.
+  
   // If all user_data pointers are equal we can assume the iterators to be
   // equal.  This should be safe since GtkTreeIter lacks destroy notification,
   // thus there is no way to attach more data fields to the iterator.
diff --git a/libs/gtkmm2/gtk/gtkmm/treeiter.h b/libs/gtkmm2/gtk/gtkmm/treeiter.h
index df41741ffa..49a639d4cf 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeiter.h
+++ b/libs/gtkmm2/gtk/gtkmm/treeiter.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEITER_H
 #define _GTKMM_TREEITER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -305,7 +304,7 @@ public:
    * you do not know the column type at compile-time.
    * If the @a data output argument is of an inappropriate C++ type then this might fail at runtime.
    * @param column The number of the column whose value you want to change.
-   * @result data An output argument which will contain the value of this column of this row.
+   * @retval data An output argument which will contain the value of this column of this row.
    */
   template <class ColumnType>
   void get_value(int column, ColumnType& data) const;
@@ -514,6 +513,5 @@ class Value<Gtk::TreeIterBase> : public Glib::Value_Boxed<Gtk::TreeIterBase>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TREEITER_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodel.cc b/libs/gtkmm2/gtk/gtkmm/treemodel.cc
index 9997d5cd91..b6989dff58 100644
--- a/libs/gtkmm2/gtk/gtkmm/treemodel.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treemodel.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treemodel.h>
 #include <gtkmm/private/treemodel_p.h>
 
@@ -33,66 +32,54 @@
 namespace
 {
 
-static gboolean proxy_foreach_iter_callback(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, void* data)
+gboolean proxy_foreach_iter_callback(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, void* data)
 {
   typedef Gtk::TreeModel::SlotForeachIter SlotType;
   SlotType& slot = *static_cast<SlotType*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return slot(Gtk::TreeModel::iterator(model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return 1;
 }
 
-static gboolean proxy_foreach_path_callback(GtkTreeModel*, GtkTreePath* path, GtkTreeIter*, void* data)
+gboolean proxy_foreach_path_callback(GtkTreeModel*, GtkTreePath* path, GtkTreeIter*, void* data)
 {
   typedef Gtk::TreeModel::SlotForeachPath SlotType;
   SlotType& slot = *static_cast<SlotType*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return slot(Gtk::TreeModel::Path(path, true));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return 1;
 }
 
-static gboolean proxy_foreach_path_and_iter_callback(GtkTreeModel* model, GtkTreePath* path,
+gboolean proxy_foreach_path_and_iter_callback(GtkTreeModel* model, GtkTreePath* path,
                                               GtkTreeIter* iter, void* data)
 {
   typedef Gtk::TreeModel::SlotForeachPathAndIter SlotType;
   SlotType& slot = *static_cast<SlotType*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     return slot(Gtk::TreeModel::Path(path, true), Gtk::TreeModel::iterator(model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return 1;
 }
@@ -173,8 +160,6 @@ bool TreeModel::iter_is_valid(const iterator& iter) const
   return (!iter.is_end_ && iter.gobj()->stamp != 0);
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-
 // Custom vfunc callbacks, because the C++ vfuncs have different parameters and return types
 // that can not be generated automatically:
 gboolean TreeModel_Class::iter_next_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
@@ -189,10 +174,8 @@ gboolean TreeModel_Class::iter_next_vfunc_callback(GtkTreeModel* self, GtkTreeIt
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       TreeModel::iterator iter_input = TreeModel::iterator(self, iter);
       TreeModel::iterator iter_next( self, iter ); //Copies iter by value.
@@ -203,13 +186,11 @@ gboolean TreeModel_Class::iter_next_vfunc_callback(GtkTreeModel* self, GtkTreeIt
         *iter = *(iter_next.gobj());
 
       return test;
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -264,10 +245,8 @@ gboolean TreeModel_Class::get_iter_vfunc_callback(GtkTreeModel* self, GtkTreeIte
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       Gtk::TreeModel::iterator iter_out(self, iter); //copies the iter by value.
       gboolean test = obj->get_iter_vfunc(Gtk::TreePath(path, true), iter_out);
@@ -277,13 +256,11 @@ gboolean TreeModel_Class::get_iter_vfunc_callback(GtkTreeModel* self, GtkTreeIte
         *iter = *(iter_out.gobj());
 
       return test;
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -331,10 +308,8 @@ gboolean TreeModel_Class::iter_children_vfunc_callback(GtkTreeModel* self, GtkTr
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       Gtk::TreeModel::iterator iter_out(self, iter); //copies the iter by value.
 
@@ -358,13 +333,11 @@ gboolean TreeModel_Class::iter_children_vfunc_callback(GtkTreeModel* self, GtkTr
         *iter = *(iter_out.gobj());
         
       return test;
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -412,10 +385,8 @@ gboolean TreeModel_Class::iter_parent_vfunc_callback(GtkTreeModel* self, GtkTree
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       Gtk::TreeModel::iterator iter_out(self, iter);
       Gtk::TreeModel::iterator child_cpp(self, child);
@@ -426,13 +397,11 @@ gboolean TreeModel_Class::iter_parent_vfunc_callback(GtkTreeModel* self, GtkTree
         *iter = *(iter_out.gobj());
 
       return test;
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -480,10 +449,8 @@ gboolean TreeModel_Class::iter_nth_child_vfunc_callback(GtkTreeModel* self, GtkT
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       Gtk::TreeModel::iterator iter_out(self, iter);
 
@@ -506,13 +473,11 @@ gboolean TreeModel_Class::iter_nth_child_vfunc_callback(GtkTreeModel* self, GtkT
         *iter = *(iter_out.gobj());
 
       return test;
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -582,10 +547,8 @@ gboolean TreeModel_Class::iter_n_children_vfunc_callback(GtkTreeModel* self, Gtk
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
 
       //Deal with the case that iter is null, as described in the C docs:
@@ -593,13 +556,11 @@ gboolean TreeModel_Class::iter_n_children_vfunc_callback(GtkTreeModel* self, Gtk
         return obj->iter_n_children_vfunc( Gtk::TreeModel::iterator(self, iter) );
       else
         return obj->iter_n_root_children_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -645,8 +606,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   return RType();
 }
 
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 void TreeModel::rows_reordered(const Path& path, const iterator& iter, const Glib::ArrayHandle<int>& new_order)
 {
@@ -654,11 +613,6 @@ void TreeModel::rows_reordered(const Path& path, const iterator& iter, const Gli
   gtk_tree_model_rows_reordered(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()), const_cast<int*>(new_order.data()));
 }
  
-void TreeModel::rows_reordered(const Path& path, const Glib::ArrayHandle<int>& new_order)
-{
-  //The size of the array seems to be based on the known number of children. murrayc.
-  gtk_tree_model_rows_reordered(gobj(), const_cast<GtkTreePath*>((path).gobj()), 0, const_cast<int*>(new_order.data()));
-}
 
 } // namespace Gtk
 
@@ -666,8 +620,7 @@ void TreeModel::rows_reordered(const Path& path, const Glib::ArrayHandle<int>& n
 namespace
 {
 
-
-static void TreeModel_signal_row_changed_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
+void TreeModel_signal_row_changed_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator& > SlotType;
@@ -675,25 +628,21 @@ static void TreeModel_signal_row_changed_callback(GtkTreeModel* self, GtkTreePat
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeModel_signal_row_changed_info =
+const Glib::SignalProxyInfo TreeModel_signal_row_changed_info =
 {
   "row_changed",
   (GCallback) &TreeModel_signal_row_changed_callback,
@@ -701,7 +650,7 @@ static const Glib::SignalProxyInfo TreeModel_signal_row_changed_info =
 };
 
 
-static void TreeModel_signal_row_inserted_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
+void TreeModel_signal_row_inserted_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator& > SlotType;
@@ -709,25 +658,21 @@ static void TreeModel_signal_row_inserted_callback(GtkTreeModel* self, GtkTreePa
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeModel_signal_row_inserted_info =
+const Glib::SignalProxyInfo TreeModel_signal_row_inserted_info =
 {
   "row_inserted",
   (GCallback) &TreeModel_signal_row_inserted_callback,
@@ -735,7 +680,7 @@ static const Glib::SignalProxyInfo TreeModel_signal_row_inserted_info =
 };
 
 
-static void TreeModel_signal_row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
+void TreeModel_signal_row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator& > SlotType;
@@ -743,25 +688,21 @@ static void TreeModel_signal_row_has_child_toggled_callback(GtkTreeModel* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeModel_signal_row_has_child_toggled_info =
+const Glib::SignalProxyInfo TreeModel_signal_row_has_child_toggled_info =
 {
   "row_has_child_toggled",
   (GCallback) &TreeModel_signal_row_has_child_toggled_callback,
@@ -769,7 +710,7 @@ static const Glib::SignalProxyInfo TreeModel_signal_row_has_child_toggled_info =
 };
 
 
-static void TreeModel_signal_row_deleted_callback(GtkTreeModel* self, GtkTreePath* path,void* data)
+void TreeModel_signal_row_deleted_callback(GtkTreeModel* self, GtkTreePath* path,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::Path& > SlotType;
@@ -777,24 +718,20 @@ static void TreeModel_signal_row_deleted_callback(GtkTreeModel* self, GtkTreePat
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeModel_signal_row_deleted_info =
+const Glib::SignalProxyInfo TreeModel_signal_row_deleted_info =
 {
   "row_deleted",
   (GCallback) &TreeModel_signal_row_deleted_callback,
@@ -802,7 +739,7 @@ static const Glib::SignalProxyInfo TreeModel_signal_row_deleted_info =
 };
 
 
-static void TreeModel_signal_rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,gint* new_order,void* data)
+void TreeModel_signal_rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path,GtkTreeIter* iter,gint* new_order,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::Path&,const TreeModel::iterator&,int* > SlotType;
@@ -810,33 +747,28 @@ static void TreeModel_signal_rows_reordered_callback(GtkTreeModel* self, GtkTree
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 , new_order
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeModel_signal_rows_reordered_info =
+const Glib::SignalProxyInfo TreeModel_signal_rows_reordered_info =
 {
   "rows_reordered",
   (GCallback) &TreeModel_signal_rows_reordered_callback,
   (GCallback) &TreeModel_signal_rows_reordered_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -887,7 +819,6 @@ void TreeModel_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_flags = &get_flags_vfunc_callback;
   klass->get_n_columns = &get_n_columns_vfunc_callback;
   klass->get_column_type = &get_column_type_vfunc_callback;
@@ -902,18 +833,13 @@ void TreeModel_Class::iface_init_function(void* g_iface, void*)
   klass->unref_node = &unref_node_vfunc_callback;
   klass->get_path = &get_path_vfunc_callback;
   klass->get_value = &get_value_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->row_changed = &row_changed_callback;
   klass->row_inserted = &row_inserted_callback;
   klass->row_has_child_toggled = &row_has_child_toggled_callback;
   klass->row_deleted = &row_deleted_callback;
   klass->rows_reordered = &rows_reordered_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 GtkTreeModelFlags TreeModel_Class::get_flags_vfunc_callback(GtkTreeModel* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -926,19 +852,15 @@ GtkTreeModelFlags TreeModel_Class::get_flags_vfunc_callback(GtkTreeModel* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return ((GtkTreeModelFlags)(obj->get_flags_vfunc()));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -955,6 +877,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef GtkTreeModelFlags RType;
   return RType();
 }
+
 gint TreeModel_Class::get_n_columns_vfunc_callback(GtkTreeModel* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -967,19 +890,15 @@ gint TreeModel_Class::get_n_columns_vfunc_callback(GtkTreeModel* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_n_columns_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -996,6 +915,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gint RType;
   return RType();
 }
+
 GType TreeModel_Class::get_column_type_vfunc_callback(GtkTreeModel* self, gint index)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1008,20 +928,16 @@ GType TreeModel_Class::get_column_type_vfunc_callback(GtkTreeModel* self, gint i
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->get_column_type_vfunc(index
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1038,6 +954,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef GType RType;
   return RType();
 }
+
 gboolean TreeModel_Class::iter_has_child_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1050,20 +967,16 @@ gboolean TreeModel_Class::iter_has_child_vfunc_callback(GtkTreeModel* self, GtkT
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->iter_has_child_vfunc(Gtk::TreeModel::iterator(self, iter)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1080,6 +993,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 void TreeModel_Class::ref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1092,20 +1006,16 @@ void TreeModel_Class::ref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* i
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->ref_node_vfunc(Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1119,6 +1029,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->ref_node)(self, iter);
   }
 }
+
 void TreeModel_Class::unref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1131,20 +1042,16 @@ void TreeModel_Class::unref_node_vfunc_callback(GtkTreeModel* self, GtkTreeIter*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->unref_node_vfunc(Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1158,6 +1065,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->unref_node)(self, iter);
   }
 }
+
 GtkTreePath* TreeModel_Class::get_path_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1170,20 +1078,16 @@ GtkTreePath* TreeModel_Class::get_path_vfunc_callback(GtkTreeModel* self, GtkTre
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return (obj->get_path_vfunc(Gtk::TreeModel::iterator(self, iter)
 )).gobj_copy();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1200,6 +1104,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef GtkTreePath* RType;
   return RType();
 }
+
 void TreeModel_Class::get_value_vfunc_callback(GtkTreeModel* self, GtkTreeIter* iter, gint column, GValue* value)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1212,22 +1117,18 @@ void TreeModel_Class::get_value_vfunc_callback(GtkTreeModel* self, GtkTreeIter*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->get_value_vfunc(Gtk::TreeModel::iterator(self, iter)
 , column
 , *reinterpret_cast<Glib::ValueBase*>(value)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1241,9 +1142,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->get_value)(self, iter, column, value);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void TreeModel_Class::row_changed_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1256,21 +1156,17 @@ void TreeModel_Class::row_changed_callback(GtkTreeModel* self, GtkTreePath* path
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_changed(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1284,6 +1180,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->row_changed)(self, path, iter);
   }
 }
+
 void TreeModel_Class::row_inserted_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1296,21 +1193,17 @@ void TreeModel_Class::row_inserted_callback(GtkTreeModel* self, GtkTreePath* pat
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_inserted(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1324,6 +1217,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->row_inserted)(self, path, iter);
   }
 }
+
 void TreeModel_Class::row_has_child_toggled_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1336,21 +1230,17 @@ void TreeModel_Class::row_has_child_toggled_callback(GtkTreeModel* self, GtkTree
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_has_child_toggled(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1364,6 +1254,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->row_has_child_toggled)(self, path, iter);
   }
 }
+
 void TreeModel_Class::row_deleted_callback(GtkTreeModel* self, GtkTreePath* path)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1376,20 +1267,16 @@ void TreeModel_Class::row_deleted_callback(GtkTreeModel* self, GtkTreePath* path
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_deleted(Gtk::TreePath(path, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1403,6 +1290,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->row_deleted)(self, path);
   }
 }
+
 void TreeModel_Class::rows_reordered_callback(GtkTreeModel* self, GtkTreePath* path, GtkTreeIter* iter, gint* new_order)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1415,22 +1303,18 @@ void TreeModel_Class::rows_reordered_callback(GtkTreeModel* self, GtkTreePath* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_rows_reordered(Gtk::TreePath(path, true)
 , Gtk::TreeModel::iterator(self, iter)
 , new_order
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1444,7 +1328,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->rows_reordered)(self, path, iter, new_order);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TreeModel_Class::wrap_new(GObject* object)
@@ -1509,27 +1392,27 @@ TreeModel::Path TreeModel::get_path(const iterator& iter) const
 
 void TreeModel::row_changed(const Path& path, const iterator& iter)
 {
-gtk_tree_model_row_changed(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj())); 
+  gtk_tree_model_row_changed(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
 }
 
 void TreeModel::row_inserted(const Path& path, const iterator& iter)
 {
-gtk_tree_model_row_inserted(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj())); 
+  gtk_tree_model_row_inserted(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
 }
 
 void TreeModel::row_has_child_toggled(const Path& path, const iterator& iter)
 {
-gtk_tree_model_row_has_child_toggled(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj())); 
+  gtk_tree_model_row_has_child_toggled(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()));
 }
 
 void TreeModel::row_deleted(const Path& path)
 {
-gtk_tree_model_row_deleted(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
+  gtk_tree_model_row_deleted(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 void TreeModel::rows_reordered(const Path& path, const iterator& iter, int* new_order)
 {
-gtk_tree_model_rows_reordered(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()), new_order); 
+  gtk_tree_model_rows_reordered(gobj(), const_cast<GtkTreePath*>((path).gobj()), const_cast<GtkTreeIter*>((iter).gobj()), new_order);
 }
 
 Glib::ustring TreeModel::get_string(const iterator& iter) const
@@ -1543,32 +1426,27 @@ Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > Tre
   return Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& >(this, &TreeModel_signal_row_changed_info);
 }
 
-
 Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > TreeModel::signal_row_inserted()
 {
   return Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& >(this, &TreeModel_signal_row_inserted_info);
 }
 
-
 Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > TreeModel::signal_row_has_child_toggled()
 {
   return Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& >(this, &TreeModel_signal_row_has_child_toggled_info);
 }
 
-
 Glib::SignalProxy1< void,const TreeModel::Path& > TreeModel::signal_row_deleted()
 {
   return Glib::SignalProxy1< void,const TreeModel::Path& >(this, &TreeModel_signal_row_deleted_info);
 }
 
-
 Glib::SignalProxy3< void,const TreeModel::Path&,const TreeModel::iterator&,int* > TreeModel::signal_rows_reordered()
 {
   return Glib::SignalProxy3< void,const TreeModel::Path&,const TreeModel::iterator&,int* >(this, &TreeModel_signal_rows_reordered_info);
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TreeModel::on_row_changed(const TreeModel::Path& path, const TreeModel::iterator& iter)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1579,6 +1457,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->row_changed)
     (*base->row_changed)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
 }
+
 void Gtk::TreeModel::on_row_inserted(const TreeModel::Path& path, const TreeModel::iterator& iter)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1589,6 +1468,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->row_inserted)
     (*base->row_inserted)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
 }
+
 void Gtk::TreeModel::on_row_has_child_toggled(const TreeModel::Path& path, const TreeModel::iterator& iter)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1599,6 +1479,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->row_has_child_toggled)
     (*base->row_has_child_toggled)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
 }
+
 void Gtk::TreeModel::on_row_deleted(const TreeModel::Path& path)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1609,6 +1490,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->row_deleted)
     (*base->row_deleted)(gobj(),const_cast<GtkTreePath*>((path).gobj()));
 }
+
 void Gtk::TreeModel::on_rows_reordered(const TreeModel::Path& path, const TreeModel::iterator& iter, int* new_order)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1619,9 +1501,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->rows_reordered)
     (*base->rows_reordered)(gobj(),const_cast<GtkTreePath*>((path).gobj()),const_cast<GtkTreeIter*>((iter).gobj()),new_order);
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 TreeModelFlags Gtk::TreeModel::get_flags_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1635,6 +1516,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef TreeModelFlags RType;
   return RType();
 }
+
 int Gtk::TreeModel::get_n_columns_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1648,6 +1530,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef int RType;
   return RType();
 }
+
 GType Gtk::TreeModel::get_column_type_vfunc(int index) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1661,6 +1544,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef GType RType;
   return RType();
 }
+
 bool Gtk::TreeModel::iter_has_child_vfunc(const iterator& iter) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1674,6 +1558,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 void Gtk::TreeModel::ref_node_vfunc(const iterator& iter) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1684,6 +1569,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->ref_node)
     (*base->ref_node)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
 }
+
 void Gtk::TreeModel::unref_node_vfunc(const iterator& iter) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1694,6 +1580,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->unref_node)
     (*base->unref_node)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj()));
 }
+
 TreeModel::Path Gtk::TreeModel::get_path_vfunc(const iterator& iter) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1707,6 +1594,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef TreeModel::Path RType;
   return RType();
 }
+
 void Gtk::TreeModel::get_value_vfunc(const iterator& iter, int column, Glib::ValueBase& value) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1717,7 +1605,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_value)
     (*base->get_value)(const_cast<GtkTreeModel*>(gobj()),const_cast<GtkTreeIter*>((iter).gobj()),column,(value).gobj());
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodel.h b/libs/gtkmm2/gtk/gtkmm/treemodel.h
index 2ac7940a3f..25e0eb92e3 100644
--- a/libs/gtkmm2/gtk/gtkmm/treemodel.h
+++ b/libs/gtkmm2/gtk/gtkmm/treemodel.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEMODEL_H
 #define _GTKMM_TREEMODEL_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -343,32 +342,13 @@ public:
    */
   void row_deleted(const Path& path);
 
- /** Emits the "rows_reordered" signal on the tree model.  This should be called by
-  * custom models when their rows have been reordered. 
-  *
-  * @param path A tree path pointing to the tree node whose children have been reordered.
-  * @param iter A valid iterator pointing to the node whose children have been reordered. See also, rows_reordered(const Path& path, const Glib::ArrayHandle<int>& new_order), if the path has a depth of 0.
-  * @param new_order An array of integers mapping the current position of each child
-  * to its old position before the re-ordering, i.e. @a new_order<literal>[newpos] = oldpos.
-  */
   void rows_reordered(const Path& path, const iterator& iter, const Glib::ArrayHandle<int>& new_order);
-
- /** Emits the "rows_reordered" signal on the tree model.  This should be called by
-  * custom models when their rows have been reordered. This method overload is for nodes whose 
-  * path has a depth of 0.
-  * @newin2p10
-  *
-  * @param path A tree path pointing to the tree node whose children have been reordered.
-  * @param new_order An array of integers mapping the current position of each child
-  * to its old position before the re-ordering, i.e. @a new_order<literal>[newpos] = oldpos.
-  */
-  void rows_reordered(const Path& path, const Glib::ArrayHandle<int>& new_order);
   
   
   /** Emits the "rows_reordered" signal on @a tree_model .  This should be called by
    * models when their rows have been reordered.
    * @param path A Gtk::TreePath pointing to the tree node whose children have been reordered.
-   * @param iter A valid Gtk::TreeIter pointing to the node whose children have been reordered, or <tt>0</tt> if the depth of @a path  is 0.
+   * @param iter A valid Gtk::TreeIter pointing to the node whose children have been reordered.
    * @param new_order An array of integers mapping the current position of each child
    * to its old position before the re-ordering,
    * i.e. @a new_order <tt>[newpos] = oldpos</tt>.
@@ -379,71 +359,36 @@ public:
   /** Generates a string representation of the iter. This string is a ':'
    * separated list of numbers. For example, "4:10:0:3" would be an
    * acceptable return value for this string.
-   * 
-   *  @a newin2p2 
    * @param iter An Gtk::TreeIter.
    * @return The string.
+   * 
+   * Since: 2.2.
    */
   Glib::ustring get_string(const iterator& iter) const;
 
  
-/**
-   * @par Prototype:
-   * <tt>void %row_changed(const TreeModel::Path& path, const TreeModel::iterator& iter)</tt>
-   */
-
   Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > signal_row_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_inserted(const TreeModel::Path& path, const TreeModel::iterator& iter)</tt>
-   */
-
   Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > signal_row_inserted();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_has_child_toggled(const TreeModel::Path& path, const TreeModel::iterator& iter)</tt>
-   */
-
   Glib::SignalProxy2< void,const TreeModel::Path&,const TreeModel::iterator& > signal_row_has_child_toggled();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_deleted(const TreeModel::Path& path)</tt>
-   */
-
   Glib::SignalProxy1< void,const TreeModel::Path& > signal_row_deleted();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %rows_reordered(const TreeModel::Path& path, const TreeModel::iterator& iter, int* new_order)</tt>
-   */
-
   Glib::SignalProxy3< void,const TreeModel::Path&,const TreeModel::iterator&,int* > signal_rows_reordered();
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual TreeModelFlags get_flags_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual int get_n_columns_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual GType get_column_type_vfunc(int index) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual TreeModelFlags get_flags_vfunc() const;
+    virtual int get_n_columns_vfunc() const;
+    virtual GType get_column_type_vfunc(int index) const;
 
   //These are only for deriving new TreeModels, which isn't very common or easy:
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   /** Override and implement this in a derived TreeModel class.
    * Sets @a iter_next to refer to the node following @a iter it at the current level.
    * If there is no next iter, false is returned and iter_next is set to be invalid.
@@ -508,7 +453,6 @@ protected:
    * @result true if the operation was possible.
    */
   virtual bool iter_nth_root_child_vfunc(int n, iterator& iter) const;
-#endif //GLIBMM_VFUNCS_ENABLED
 
   
   /** Override and implement this in a derived TreeModel class.
@@ -517,12 +461,8 @@ protected:
    * @param iter The iterator to test for children.
    * @result true if @a iter has children.
    */
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool iter_has_child_vfunc(const iterator& iter) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual bool iter_has_child_vfunc(const iterator& iter) const;
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   /** Override and implement this in a derived TreeModel class.
    * Returns the number of children that @a iter has.
    * See also iter_n_root_children_vfunc().  
@@ -539,7 +479,6 @@ protected:
    * @result The number of children at the root level.
    */
   virtual int iter_n_root_children_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
 
   /** Override and implement this in a derived TreeModel class.
    * Lets the tree ref the node.  This is an optional method for models to
@@ -557,10 +496,7 @@ protected:
    *
    * @param iter the iterator.
    */
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void ref_node_vfunc(const iterator& iter) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void ref_node_vfunc(const iterator& iter) const;
 
   /** Override and implement this in a derived TreeModel class.
    * Lets the tree unref the node.  This is an optional method for models to
@@ -572,10 +508,7 @@ protected:
    *
    * @param iter the iterator.
    */
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void unref_node_vfunc(const iterator& iter) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void unref_node_vfunc(const iterator& iter) const;
 
   /** Override and implement this in a derived TreeModel class.
    * Returns a Path referenced by @a iter.
@@ -585,10 +518,7 @@ protected:
    */
  
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual TreeModel::Path get_path_vfunc(const iterator& iter) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual TreeModel::Path get_path_vfunc(const iterator& iter) const;
 
   /** Override and implement this in a derived TreeModel class.
    * Initializes and sets @a value to that at @a column.
@@ -597,13 +527,10 @@ protected:
    * @param column The column to lookup the value at.
    * @param value An empty Glib:Value to set.
    */
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void get_value_vfunc(const iterator& iter, int column, Glib::ValueBase& value) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void get_value_vfunc(const iterator& iter, int column, Glib::ValueBase& value) const;
 
   /** Override and implement this in a derived TreeModel class.
-   * @note This virtual method is not recommended.  To check
+   * @note This virtual method is <em>deprecated</em>.  If you want to check
    * whether an iterator is valid, call TreeStore::iter_is_valid(),
    * ListStore::iter_is_valid() or TreeModelSort::iter_is_valid() directly
    * instead.  Because these methods are intended to be used only for debugging
@@ -638,22 +565,16 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_row_changed(const TreeModel::Path& path, const TreeModel::iterator& iter);
   virtual void on_row_inserted(const TreeModel::Path& path, const TreeModel::iterator& iter);
   virtual void on_row_has_child_toggled(const TreeModel::Path& path, const TreeModel::iterator& iter);
   virtual void on_row_deleted(const TreeModel::Path& path);
   virtual void on_rows_reordered(const TreeModel::Path& path, const TreeModel::iterator& iter, int* new_order);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -672,6 +593,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TREEMODEL_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelfilter.cc b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.cc
index e19571acf2..08670fb795 100644
--- a/libs/gtkmm2/gtk/gtkmm/treemodelfilter.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treemodelfilter.h>
 #include <gtkmm/private/treemodelfilter_p.h>
 
@@ -26,69 +25,110 @@
 
 #include <gtk/gtktreemodelfilter.h>
 
+namespace //anonymous
+{
+
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Visible
+{
+public:
+  typedef Gtk::TreeModelFilter::SlotVisible SlotType;
+
+  SignalProxy_Visible(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_Visible();
+
+  static gboolean gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Visible::~SignalProxy_Visible()
+{}
 
-static gboolean SignalProxy_Visible_gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, gpointer data)
+gboolean SignalProxy_Visible::gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, gpointer data)
 {
-  Gtk::TreeModelFilter::SlotVisible* the_slot = static_cast<Gtk::TreeModelFilter::SlotVisible*>(data);
+  SignalProxy_Visible *const self = static_cast<SignalProxy_Visible*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENAB
-    return (*the_slot)( Gtk::TreeModel::const_iterator(model, iter) );
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    return (self->slot_)( Gtk::TreeModel::const_iterator(model, iter) );
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return FALSE; //An arbitary default, just to avoid the compiler warning.
 }
 
-static void SignalProxy_Visible_gtk_callback_destroy(void* data)
+void SignalProxy_Visible::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::TreeModelFilter::SlotVisible*>(data);
+  delete static_cast<SignalProxy_Visible*>(data);
 }
 
 
-static void SignalProxy_Modify_gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, gint column, gpointer data)
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Modify
 {
-  Gtk::TreeModelFilter::SlotModify* the_slot = static_cast<Gtk::TreeModelFilter::SlotModify*>(data);
+public:
+  typedef Gtk::TreeModelFilter::SlotModify SlotType;
+
+  SignalProxy_Modify(const SlotType& slot)
+  : slot_(slot) {}
+
+  ~SignalProxy_Modify();
+
+  static void gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, gint column, gpointer data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Modify::~SignalProxy_Modify()
+{}
+
+void SignalProxy_Modify::gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, GValue* value, gint column, gpointer data)
+{
+  SignalProxy_Modify *const self = static_cast<SignalProxy_Modify*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     //Initialize the input parameter with the appropriate type for this column.
     //Then the C++ handler can just use operator==() without calling init on the value output arg:
     Glib::ValueBase cppValue;
     GType column_type = gtk_tree_model_get_column_type(model, column);
     cppValue.init(column_type);
     
-    (*the_slot)( Gtk::TreeModel::const_iterator(model, iter), cppValue, column );
+    (self->slot_)( Gtk::TreeModel::const_iterator(model, iter), cppValue, column );
 
     //GTK+ has already done this for us: g_value_init(value, column_type);
 
     //If the C++ handler has inited value with an inappropriate GType, then this will fail,
     //but they should not do that because it makes no sense.
-    g_value_copy(cppValue.gobj() /* source */, value /* destination */);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED  
+    g_value_copy(cppValue.gobj() /* source */, value /* destination */);  
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void SignalProxy_Modify_gtk_callback_destroy(void* data)
+void SignalProxy_Modify::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::TreeModelFilter::SlotModify*>(data);
+  delete static_cast<SignalProxy_Modify*>(data);
 }
 
 
+} // anonymous namespace
+
+
 typedef Gtk::TreeModel::Path Path; //So that the generated method implemenations can use this a return type.
 
 namespace Gtk
@@ -110,14 +150,14 @@ TreeModelFilter::TreeModelFilter(const Glib::RefPtr<TreeModel>& child_model, con
 
 void TreeModelFilter::set_visible_func(const SlotVisible& slot)
 {
-  // Create a copy of the slot.  A pointer to this will be passed
+  // Create a signal proxy.  A pointer to this will be passed
   // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_Visible_gtk_callback_destroy() is called.
-  SlotVisible* slot_copy = new SlotVisible(slot);
+  // when SignalProxy_Visible::gtk_callback_destroy() is called.
+  SignalProxy_Visible *const pSignalProxy = new SignalProxy_Visible(slot);
 
   gtk_tree_model_filter_set_visible_func(gobj(),
-      &SignalProxy_Visible_gtk_callback, slot_copy,
-      &SignalProxy_Visible_gtk_callback_destroy);
+      &SignalProxy_Visible::gtk_callback, pSignalProxy,
+      &SignalProxy_Visible::gtk_callback_destroy);
 }
 
 
@@ -147,15 +187,15 @@ TreeModel::iterator TreeModelFilter::convert_iter_to_child_iter(const iterator&
 
 void TreeModelFilter::set_modify_func(const TreeModelColumnRecord& columns, const SlotModify& slot)
 {
-  // Create a copy of the slot.  A pointer to this will be passed
+  // Create a signal proxy.  A pointer to this will be passed
   // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_Modify_gtk_callback_destroy() is called.
-  SlotModify* slot_copy = new SlotModify(slot);
+  // when SignalProxy_Modify::gtk_callback_destroy() is called.
+  SignalProxy_Modify *const pSignalProxy = new SignalProxy_Modify(slot);
 
   gtk_tree_model_filter_set_modify_func(gobj(),
     columns.size(), const_cast<GType*>(columns.types()),
-    &SignalProxy_Modify_gtk_callback, slot_copy,
-    &SignalProxy_Modify_gtk_callback_destroy);
+    &SignalProxy_Modify::gtk_callback, pSignalProxy,
+    &SignalProxy_Modify::gtk_callback_destroy);
 }
 
 void TreeModelFilter::set_value_impl(const iterator& /* row */, int /* column */, const Glib::ValueBase& /* value */)
@@ -216,19 +256,8 @@ void TreeModelFilter_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* TreeModelFilter_Class::wrap_new(GObject* object)
 {
@@ -281,47 +310,44 @@ Glib::RefPtr<TreeModelFilter> TreeModelFilter::create(const Glib::RefPtr<TreeMod
 }
 void TreeModelFilter::set_visible_column(const TreeModelColumnBase& column)
 {
-gtk_tree_model_filter_set_visible_column(gobj(), (column).index()); 
+  gtk_tree_model_filter_set_visible_column(gobj(), (column).index());
 }
 
 void TreeModelFilter::set_visible_column(int column)
 {
-gtk_tree_model_filter_set_visible_column(gobj(), column); 
+  gtk_tree_model_filter_set_visible_column(gobj(), column);
 }
 
 Glib::RefPtr<TreeModel> TreeModelFilter::get_model()
 {
 
   Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_tree_model_filter_get_model(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TreeModel> TreeModelFilter::get_model() const
 {
-  return const_cast<TreeModelFilter*>(this)->get_model();
-}
 
-#ifndef GTKMM_DISABLE_DEPRECATED
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_tree_model_filter_get_model(const_cast<GtkTreeModelFilter*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
 
 Path TreeModelFilter::convert_child_path_to_path(const Path& child_path)
 {
   return Gtk::TreePath(gtk_tree_model_filter_convert_child_path_to_path(gobj(), const_cast<GtkTreePath*>((child_path).gobj())), false);
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 Path TreeModelFilter::convert_path_to_child_path(const Path& filter_path)
 {
   return Gtk::TreePath(gtk_tree_model_filter_convert_path_to_child_path(gobj(), const_cast<GtkTreePath*>((filter_path).gobj())), false);
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 Path TreeModelFilter::convert_child_path_to_path(const Path& child_path) const
 {
   return Gtk::TreePath(gtk_tree_model_filter_convert_child_path_to_path(const_cast<GtkTreeModelFilter*>(gobj()), const_cast<GtkTreePath*>((child_path).gobj())), false);
@@ -334,22 +360,15 @@ Path TreeModelFilter::convert_path_to_child_path(const Path& filter_path) const
 
 void TreeModelFilter::refilter()
 {
-gtk_tree_model_filter_refilter(gobj()); 
+  gtk_tree_model_filter_refilter(gobj());
 }
 
 void TreeModelFilter::clear_cache()
 {
-gtk_tree_model_filter_clear_cache(gobj()); 
+  gtk_tree_model_filter_clear_cache(gobj());
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelfilter.h b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.h
index 3cd91bf571..66ddb7dc90 100644
--- a/libs/gtkmm2/gtk/gtkmm/treemodelfilter.h
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelfilter.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEMODELFILTER_H
 #define _GTKMM_TREEMODELFILTER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -159,7 +158,7 @@ public:
    * G::TYPE_BOOLEAN, where <tt>true</tt> means that a row is visible, and <tt>false</tt>
    * if not.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param column A <tt>int</tt> which is the column containing the visible information.
    */
   void set_visible_column(const TreeModelColumnBase& column);
@@ -169,7 +168,7 @@ public:
    * G::TYPE_BOOLEAN, where <tt>true</tt> means that a row is visible, and <tt>false</tt>
    * if not.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param column A <tt>int</tt> which is the column containing the visible information.
    */
   void set_visible_column(int column);
@@ -178,14 +177,14 @@ public:
   /** Returns a pointer to the child model of @a filter .
    * @return A pointer to a Gtk::TreeModel.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<TreeModel> get_model();
   
   /** Returns a pointer to the child model of @a filter .
    * @return A pointer to a Gtk::TreeModel.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const TreeModel> get_model() const;
 
@@ -205,38 +204,29 @@ public:
 
   //TODO: Remove these deprecated non-const versions when we can break ABI:
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
   /** Converts @a child_path  to a path relative to @a filter . That is, @a child_path 
    * points to a path in the child model. The rerturned path will point to the
    * same row in the filtered model. If @a child_path  isn't a valid path on the
    * child model, then <tt>0</tt> is returned.
-   * @deprecated Use convert_child_path_to_path(const Path& child_path) const
    * @param child_path A Gtk::TreePath to convert.
    * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Path convert_child_path_to_path(const Path& child_path);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+  
   /** Converts @a filter_path  to a path on the child model of @a filter . That is,
    *  @a filter_path  points to a location in @a filter . The returned path will
    * point to the same location in the model not being filtered. If @a filter_path 
    * does not point to a location in the child model, <tt>0</tt> is returned.
-   * @deprecated convert_path_to_child_path(const Path& filter_path) const
    * @param filter_path A Gtk::TreePath to convert.
    * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Path convert_path_to_child_path(const Path& filter_path);
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
+  
   /** Converts @a child_path  to a path relative to @a filter . That is, @a child_path 
    * points to a path in the child model. The rerturned path will point to the
    * same row in the filtered model. If @a child_path  isn't a valid path on the
@@ -244,7 +234,7 @@ public:
    * @param child_path A Gtk::TreePath to convert.
    * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Path convert_child_path_to_path(const Path& child_path) const;
   
@@ -255,7 +245,7 @@ public:
    * @param filter_path A Gtk::TreePath to convert.
    * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Path convert_path_to_child_path(const Path& filter_path) const;
 
@@ -263,7 +253,7 @@ public:
   /** Emits ::row_changed for each row in the child model, which causes
    * the filter to re-evaluate whether a row is visible or not.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void refilter();
   
@@ -274,7 +264,7 @@ public:
    * a lot of unreffed access to nodes. As a side effect of this function,
    * all unreffed itters will be invalid.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void clear_cache();
 
@@ -286,17 +276,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelsort.cc b/libs/gtkmm2/gtk/gtkmm/treemodelsort.cc
index 4c0c8e8966..00964ef5e0 100644
--- a/libs/gtkmm2/gtk/gtkmm/treemodelsort.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelsort.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treemodelsort.h>
 #include <gtkmm/private/treemodelsort_p.h>
 
@@ -125,19 +124,8 @@ void TreeModelSort_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* TreeModelSort_Class::wrap_new(GObject* object)
 {
@@ -195,15 +183,20 @@ Glib::RefPtr<TreeModel> TreeModelSort::get_model()
 {
 
   Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_tree_model_sort_get_model(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TreeModel> TreeModelSort::get_model() const
 {
-  return const_cast<TreeModelSort*>(this)->get_model();
+
+  Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_tree_model_sort_get_model(const_cast<GtkTreeModelSort*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Path TreeModelSort::convert_child_path_to_path(const Path& child_path) const
@@ -218,12 +211,12 @@ Path TreeModelSort::convert_path_to_child_path(const Path& sorted_path) const
 
 void TreeModelSort::reset_default_sort_func()
 {
-gtk_tree_model_sort_reset_default_sort_func(gobj()); 
+  gtk_tree_model_sort_reset_default_sort_func(gobj());
 }
 
 void TreeModelSort::clear_cache()
 {
-gtk_tree_model_sort_clear_cache(gobj()); 
+  gtk_tree_model_sort_clear_cache(gobj());
 }
 
 bool TreeModelSort::iter_is_valid(const iterator& iter) const
@@ -232,13 +225,6 @@ bool TreeModelSort::iter_is_valid(const iterator& iter) const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treemodelsort.h b/libs/gtkmm2/gtk/gtkmm/treemodelsort.h
index 1b0f861c50..fd56c18d29 100644
--- a/libs/gtkmm2/gtk/gtkmm/treemodelsort.h
+++ b/libs/gtkmm2/gtk/gtkmm/treemodelsort.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEMODELSORT_H
 #define _GTKMM_TREEMODELSORT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -45,22 +44,6 @@ namespace Gtk
 {
 
 /** A wrapper which makes an underlying Gtk::TreeModel sortable.
- *
- * The TreeModelSort is a model which implements the TreeSortable interface. 
- * It does not hold any data itself, but rather is created with
- * a child model and proxies its data.  It has identical column types to
- * this child model, and the changes in the child are propagated.  The
- * primary purpose of this model is to provide a way to sort a different
- * model without modifying it. Note that the sort function used by
- * TreeModelSort is not guaranteed to be stable. 
- *
- * For instance, you might create two TreeView widgets each with a
- * view of the same data.  If the model is wrapped by a
- * TreeModelSort then the two TreeViews can each sort their
- * view of the data without affecting the other.  By contrast, if we
- * simply put the same model in each widget, then sorting the first would
- * sort the second.
- *
  * @ingroup TreeView
  */
 
@@ -130,8 +113,8 @@ public:
   
   /** Converts @a child_path  to a path relative to @a tree_model_sort .  That is,
    *  @a child_path  points to a path in the child model.  The returned path will
-   * point to the same row in the sorted model.  If @a child_path  isn't a valid 
-   * path on the child model, then <tt>0</tt> is returned.
+   * point to the same row in the sorted model.  If @a child_path  isn't a valid path
+   * on the child model, then <tt>0</tt> is returned.
    * @param child_path A Gtk::TreePath to convert.
    * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
    */
@@ -145,11 +128,10 @@ public:
   iterator convert_child_iter_to_iter(const iterator& child_iter) const;
 
   
-  /** Converts @a sorted_path  to a path on the child model of @a tree_model_sort .  
-   * That is, @a sorted_path  points to a location in @a tree_model_sort .  The 
-   * returned path will point to the same location in the model not being 
-   * sorted.  If @a sorted_path  does not point to a location in the child model, 
-   * <tt>0</tt> is returned.
+  /** Converts @a sorted_path  to a path on the child model of @a tree_model_sort .  That
+   * is, @a sorted_path  points to a location in @a tree_model_sort .  The returned path
+   * will point to the same location in the model not being sorted.  If @a sorted_path  
+   * does not point to a location in the child model, <tt>0</tt> is returned.
    * @param sorted_path A Gtk::TreePath to convert.
    * @return A newly allocated Gtk::TreePath, or <tt>0</tt>.
    */
@@ -180,15 +162,14 @@ public:
   void clear_cache();
 
   
-  /** &lt;warning&gt;
-   * This function is slow. Only use it for debugging and/or testing purposes.
-   * &lt;/warning&gt;
+  /** WARNING: This function is slow. Only use it for debugging and/or testing
+   * purposes.
    * 
    * Checks if the given iter is a valid iter for this Gtk::TreeModelSort.
    * @param iter A Gtk::TreeIter.
    * @return <tt>true</tt> if the iter is valid, <tt>false</tt> if the iter is invalid.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool iter_is_valid(const iterator& iter) const;
 
@@ -200,17 +181,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/treepath.cc b/libs/gtkmm2/gtk/gtkmm/treepath.cc
index 937c14ce28..a84164113a 100644
--- a/libs/gtkmm2/gtk/gtkmm/treepath.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treepath.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treepath.h>
 #include <gtkmm/private/treepath_p.h>
 
@@ -138,8 +137,7 @@ bool TreePath::set_in_selection_data(SelectionData& selection_data, const Glib::
   return gtk_tree_set_row_drag_data(selection_data.gobj(), const_cast<GtkTreeModel*>(model->gobj()), const_cast<GtkTreePath*>(gobj()));  
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+//deprecated:
 Glib::ArrayHandle<int> TreePath::get_indices() const
 {
   // gtk_tree_path_get_indices() returns a pointer to an internal array,
@@ -149,8 +147,6 @@ Glib::ArrayHandle<int> TreePath::get_indices() const
                                 gtk_tree_path_get_depth(gobject_),
                                 Glib::OWNERSHIP_NONE);
 }
-#endif // GTKMM_DISABLE_DEPRECATED
-
   
 } // namespace Gtk
 
@@ -227,17 +223,17 @@ GtkTreePath* TreePath::gobj_copy() const
 
 void TreePath::push_back(int index)
 {
-gtk_tree_path_append_index(gobj(), index); 
+  gtk_tree_path_append_index(gobj(), index);
 }
 
 void TreePath::push_front(int index)
 {
-gtk_tree_path_prepend_index(gobj(), index); 
+  gtk_tree_path_prepend_index(gobj(), index);
 }
 
 void TreePath::next()
 {
-gtk_tree_path_next(gobj()); 
+  gtk_tree_path_next(gobj());
 }
 
 bool TreePath::prev()
@@ -252,7 +248,7 @@ bool TreePath::up()
 
 void TreePath::down()
 {
-gtk_tree_path_down(gobj()); 
+  gtk_tree_path_down(gobj());
 }
 
 bool TreePath::is_ancestor(const TreePath& descendant) const
@@ -302,33 +298,21 @@ bool operator>=(const TreePath& lhs, const TreePath& rhs)
 }
 
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void TreePath::append_index(int index)
 {
-gtk_tree_path_append_index(gobj(), index); 
+  gtk_tree_path_append_index(gobj(), index);
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void TreePath::prepend_index(int index)
 {
-gtk_tree_path_prepend_index(gobj(), index); 
+  gtk_tree_path_prepend_index(gobj(), index);
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 int TreePath::get_depth() const
 {
   return gtk_tree_path_get_depth(const_cast<GtkTreePath*>(gobj()));
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
 } // namespace Gtk
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treepath.h b/libs/gtkmm2/gtk/gtkmm/treepath.h
index dff5b457d9..8e41e81284 100644
--- a/libs/gtkmm2/gtk/gtkmm/treepath.h
+++ b/libs/gtkmm2/gtk/gtkmm/treepath.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEPATH_H
 #define _GTKMM_TREEPATH_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -206,43 +205,31 @@ public:
 
 
 #ifndef GTKMM_DISABLE_DEPRECATED
-
+  /// @deprecated replaced by push_back():
+  
   /** Appends a new index to a path.  As a result, the depth of the path is
    * increased.
-   * @deprecated replaced by push_back()
    * @param index The index.
    */
   void append_index(int index);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+  /// @deprecated replaced by push_front():
+  
   /** Prepends a new index to a path.  As a result, the depth of the path is
    * increased.
-   * @deprecated replaced by push_front().
    * @param index The index.
    */
   void prepend_index(int index);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+  /// @deprecated replaced by size():
+  
   /** Returns the current depth of @a path .
-   * @deprecated replaced by size().
    * @return The depth of @a path .
    */
   int get_depth() const;
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+  
   /// @deprecated replaced by begin(), end(), and operator[]
   Glib::ArrayHandle<int> get_indices() const;
-#endif // GTKMM_DISABLE_DEPRECATED
-
+#endif
+  
   
   /**
    * Obtains a Gtk::TreeModel and Gtk::TreeModel::Path from selection data of target type
@@ -411,6 +398,5 @@ class Value<Gtk::TreePath> : public Glib::Value_Boxed<Gtk::TreePath>
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TREEPATH_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treerowreference.cc b/libs/gtkmm2/gtk/gtkmm/treerowreference.cc
index 3aa677fef9..591323f942 100644
--- a/libs/gtkmm2/gtk/gtkmm/treerowreference.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treerowreference.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treerowreference.h>
 #include <gtkmm/private/treerowreference_p.h>
 
@@ -118,16 +117,6 @@ TreeModel::Path TreeRowReference::get_path() const
   return Gtk::TreePath(gtk_tree_row_reference_get_path(const_cast<GtkTreeRowReference*>(gobj())), false);
 }
 
-Glib::RefPtr<TreeModel> TreeRowReference::get_model()
-{
-  return Glib::wrap(gtk_tree_row_reference_get_model(gobj()));
-}
-
-Glib::RefPtr<const TreeModel> TreeRowReference::get_model() const
-{
-  return const_cast<TreeRowReference*>(this)->get_model();
-}
-
 bool TreeRowReference::is_valid() const
 {
   return gtk_tree_row_reference_valid(const_cast<GtkTreeRowReference*>(gobj()));
diff --git a/libs/gtkmm2/gtk/gtkmm/treerowreference.h b/libs/gtkmm2/gtk/gtkmm/treerowreference.h
index 640addf509..034981d478 100644
--- a/libs/gtkmm2/gtk/gtkmm/treerowreference.h
+++ b/libs/gtkmm2/gtk/gtkmm/treerowreference.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEROWREFERENCE_H
 #define _GTKMM_TREEROWREFERENCE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -93,23 +92,6 @@ public:
   TreeModel::Path get_path() const;
 
   
-  /** Returns the model which @a reference  is monitoring in order to appropriately
-   * the path.
-   * @return The model, or <tt>0</tt>.
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<TreeModel> get_model();
-  
-  /** Returns the model which @a reference  is monitoring in order to appropriately
-   * the path.
-   * @return The model, or <tt>0</tt>.
-   * 
-   * @newin2p8.
-   */
-  Glib::RefPtr<const TreeModel> get_model() const;
-
-  
   /** Returns <tt>true</tt> if the %reference is non-<tt>0</tt> and refers to a current valid
    * path.
    * @return <tt>true</tt> if %reference points to a valid path.
@@ -152,6 +134,5 @@ class Value<Gtk::TreeRowReference> : public Glib::Value_Boxed<Gtk::TreeRowRefere
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TREEROWREFERENCE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treeselection.cc b/libs/gtkmm2/gtk/gtkmm/treeselection.cc
index 5c7ab95564..6a6ffffdcc 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeselection.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treeselection.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treeselection.h>
 #include <gtkmm/private/treeselection_p.h>
 
@@ -28,78 +27,88 @@
 #include <gtk/gtktreeselection.h>
 
 
-static void proxy_foreach_selection_iter_callback(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, void* data)
+namespace
+{
+
+void proxy_foreach_selection_iter_callback(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, void* data)
 {
   typedef Gtk::TreeSelection::SlotForeachIter SlotType;
   SlotType& slot = *static_cast<SlotType*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     slot(Gtk::TreeModel::iterator(model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void proxy_foreach_selection_path_callback(GtkTreeModel*, GtkTreePath* path, GtkTreeIter*, void* data)
+void proxy_foreach_selection_path_callback(GtkTreeModel*, GtkTreePath* path, GtkTreeIter*, void* data)
 {
   typedef Gtk::TreeSelection::SlotForeachPath SlotType;
   SlotType& slot = *static_cast<SlotType*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     slot(Gtk::TreeModel::Path(path, true));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void proxy_foreach_selection_path_and_iter_callback(GtkTreeModel* model, GtkTreePath* path,
+void proxy_foreach_selection_path_and_iter_callback(GtkTreeModel* model, GtkTreePath* path,
                                                     GtkTreeIter* iter, void* data)
 {
   typedef Gtk::TreeSelection::SlotForeachPathAndIter SlotType;
   SlotType& slot = *static_cast<SlotType*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     slot(Gtk::TreeModel::Path(path, true), Gtk::TreeModel::iterator(model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 
-static gboolean SignalProxy_Select_gtk_callback(GtkTreeSelection*, GtkTreeModel* model, GtkTreePath* path,
+// This Signal Proxy allows the C++ coder to specify
+// a sigc::slot instead of a static function.
+class SignalProxy_Select
+{
+public:
+  typedef Gtk::TreeSelection::SlotSelect SlotType;
+
+  SignalProxy_Select(const SlotType& slot) : slot_(slot) {}
+  ~SignalProxy_Select();
+
+  static gboolean gtk_callback(GtkTreeSelection*, GtkTreeModel* model, GtkTreePath* path,
+                               gboolean path_currently_selected, void* data);
+
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Select::~SignalProxy_Select()
+{}
+
+gboolean SignalProxy_Select::gtk_callback(GtkTreeSelection*, GtkTreeModel* model, GtkTreePath* path,
                                           gboolean path_currently_selected, void* data)
 {
-  const Gtk::TreeSelection::SlotSelect* the_slot = static_cast<Gtk::TreeSelection::SlotSelect*>(data);
+  SignalProxy_Select *const self = static_cast<SignalProxy_Select*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    return (*the_slot)(Glib::wrap(model, true),   // take copy
+    return (self->slot_)(Glib::wrap(model, true),   // take copy
                          Gtk::TreePath(path, true), // take copy
                          path_currently_selected);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
@@ -107,28 +116,29 @@ static gboolean SignalProxy_Select_gtk_callback(GtkTreeSelection*, GtkTreeModel*
   }
 
   return 0;
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void SignalProxy_Select_gtk_callback_destroy(void* data)
+void SignalProxy_Select::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::TreeSelection::SlotSelect*>(data);
+  delete static_cast<SignalProxy_Select*>(data);
 }
 
+} // anonymous namespace
+
 
 namespace Gtk
 {
 
 void TreeSelection::set_select_function(const SlotSelect& slot)
 {
-  // Create a copy of the slot.  A pointer to this will be passed
+  // Create a signal proxy.  A pointer to this will be passed
   // through the callback's data parameter.  It will be deleted
-  // when SignalProxy_Select_gtk_callback_destroy() is called.
-  SlotSelect* slot_copy = new SlotSelect(slot);
+  // when SignalProxy_Select::gtk_callback_destroy() is called.
+  SignalProxy_Select *const pSignalProxy = new SignalProxy_Select(slot);
 
   gtk_tree_selection_set_select_function(gobj(),
-      &SignalProxy_Select_gtk_callback, slot_copy,
-      &SignalProxy_Select_gtk_callback_destroy);
+      &SignalProxy_Select::gtk_callback, pSignalProxy,
+      &SignalProxy_Select::gtk_callback_destroy);
 }
 
 Glib::RefPtr<TreeModel> TreeSelection::get_model()
@@ -208,15 +218,13 @@ TreeSelection::ListHandle_Path TreeSelection::get_selected_rows(Glib::RefPtr<Tre
 namespace
 {
 
-
-static const Glib::SignalProxyInfo TreeSelection_signal_changed_info =
+const Glib::SignalProxyInfo TreeSelection_signal_changed_info =
 {
   "changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -263,18 +271,10 @@ void TreeSelection_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->changed = &changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void TreeSelection_Class::changed_callback(GtkTreeSelection* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -287,19 +287,15 @@ void TreeSelection_Class::changed_callback(GtkTreeSelection* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -312,7 +308,6 @@ void TreeSelection_Class::changed_callback(GtkTreeSelection* self)
       (*base->changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TreeSelection_Class::wrap_new(GObject* object)
@@ -358,7 +353,7 @@ GType TreeSelection::get_base_type()
 
 void TreeSelection::set_mode(SelectionMode type)
 {
-gtk_tree_selection_set_mode(gobj(), ((GtkSelectionMode)(type))); 
+  gtk_tree_selection_set_mode(gobj(), ((GtkSelectionMode)(type)));
 }
 
 SelectionMode TreeSelection::get_mode() const
@@ -373,7 +368,7 @@ TreeView* TreeSelection::get_tree_view()
 
 const TreeView* TreeSelection::get_tree_view() const
 {
-  return const_cast<TreeSelection*>(this)->get_tree_view();
+  return Glib::wrap(gtk_tree_selection_get_tree_view(const_cast<GtkTreeSelection*>(gobj())));
 }
 
 int TreeSelection::count_selected_rows() const
@@ -383,37 +378,37 @@ int TreeSelection::count_selected_rows() const
 
 void TreeSelection::select(const TreeModel::Path& path)
 {
-gtk_tree_selection_select_path(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
+  gtk_tree_selection_select_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 void TreeSelection::select(const TreeModel::iterator& iter)
 {
-gtk_tree_selection_select_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj())); 
+  gtk_tree_selection_select_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj()));
 }
 
 void TreeSelection::select(const TreeModel::Row& row)
 {
-gtk_tree_selection_select_iter(gobj(), const_cast<GtkTreeIter*>((row).gobj())); 
+  gtk_tree_selection_select_iter(gobj(), const_cast<GtkTreeIter*>((row).gobj()));
 }
 
 void TreeSelection::select(const TreeModel::Path& start_path, const TreeModel::Path& end_path)
 {
-gtk_tree_selection_select_range(gobj(), const_cast<GtkTreePath*>((start_path).gobj()), const_cast<GtkTreePath*>((end_path).gobj())); 
+  gtk_tree_selection_select_range(gobj(), const_cast<GtkTreePath*>((start_path).gobj()), const_cast<GtkTreePath*>((end_path).gobj()));
 }
 
 void TreeSelection::unselect(const TreeModel::Path& path)
 {
-gtk_tree_selection_unselect_path(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
+  gtk_tree_selection_unselect_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 void TreeSelection::unselect(const TreeModel::Path& start_path, const TreeModel::Path& end_path)
 {
-gtk_tree_selection_unselect_range(gobj(), const_cast<GtkTreePath*>((start_path).gobj()), const_cast<GtkTreePath*>((end_path).gobj())); 
+  gtk_tree_selection_unselect_range(gobj(), const_cast<GtkTreePath*>((start_path).gobj()), const_cast<GtkTreePath*>((end_path).gobj()));
 }
 
 void TreeSelection::unselect(const TreeModel::iterator& iter)
 {
-gtk_tree_selection_unselect_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj())); 
+  gtk_tree_selection_unselect_iter(gobj(), const_cast<GtkTreeIter*>((iter).gobj()));
 }
 
 bool TreeSelection::is_selected(const TreeModel::Path& path) const
@@ -428,12 +423,12 @@ bool TreeSelection::is_selected(const TreeModel::iterator& iter) const
 
 void TreeSelection::select_all()
 {
-gtk_tree_selection_select_all(gobj()); 
+  gtk_tree_selection_select_all(gobj());
 }
 
 void TreeSelection::unselect_all()
 {
-gtk_tree_selection_unselect_all(gobj()); 
+  gtk_tree_selection_unselect_all(gobj());
 }
 
 
@@ -443,7 +438,6 @@ Glib::SignalProxy0< void > TreeSelection::signal_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TreeSelection::on_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -453,10 +447,6 @@ void Gtk::TreeSelection::on_changed()
   if(base && base->changed)
     (*base->changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/treeselection.h b/libs/gtkmm2/gtk/gtkmm/treeselection.h
index e0bf0ce9f3..da3cac7285 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeselection.h
+++ b/libs/gtkmm2/gtk/gtkmm/treeselection.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREESELECTION_H
 #define _GTKMM_TREESELECTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -212,7 +211,7 @@ public:
   /** Returns the number of rows that have been selected in @a tree .
    * @return The number of rows selected.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   int count_selected_rows() const;
 
@@ -300,7 +299,7 @@ public:
   /** Unselects a range of nodes, determined by @a start_path  and @a end_path 
    * inclusive.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param start_path The initial node of the range.
    * @param end_path The initial node of the range.
    */
@@ -336,11 +335,6 @@ public:
   void unselect_all();
   
   
-/**
-   * @par Prototype:
-   * <tt>void %changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_changed();
 
 
@@ -348,18 +342,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/treesortable.cc b/libs/gtkmm2/gtk/gtkmm/treesortable.cc
index 7150a99858..3318bd4d0c 100644
--- a/libs/gtkmm2/gtk/gtkmm/treesortable.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treesortable.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treesortable.h>
 #include <gtkmm/private/treesortable_p.h>
 
@@ -24,17 +23,41 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-static int SignalProxy_Compare_gtk_callback(GtkTreeModel* model, GtkTreeIter* lhs, GtkTreeIter* rhs, void* data)
+namespace
+{
+
+// This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Compare
+{
+public:
+  typedef Gtk::TreeSortable::SlotCompare SlotType;
+
+  explicit SignalProxy_Compare(const SlotType& slot);
+  ~SignalProxy_Compare();
+
+  static int  gtk_callback(GtkTreeModel* model, GtkTreeIter* lhs, GtkTreeIter* rhs, void* data);
+  static void gtk_callback_destroy(void* data);
+
+private:
+  SlotType slot_;
+};
+
+SignalProxy_Compare::SignalProxy_Compare(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Compare::~SignalProxy_Compare()
+{}
+
+int SignalProxy_Compare::gtk_callback(GtkTreeModel* model, GtkTreeIter* lhs, GtkTreeIter* rhs, void* data)
 {
-  Gtk::TreeSortable::SlotCompare* the_slot = static_cast<Gtk::TreeSortable::SlotCompare*>(data);
+  SignalProxy_Compare *const self = static_cast<SignalProxy_Compare*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     // use Slot::operator()
-    return (*the_slot)(Gtk::TreeIter(model, lhs), Gtk::TreeIter(model, rhs));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    return (self->slot_)(Gtk::TreeIter(model, lhs), Gtk::TreeIter(model, rhs));
   }
   catch(...)
   {
@@ -42,25 +65,27 @@ static int SignalProxy_Compare_gtk_callback(GtkTreeModel* model, GtkTreeIter* lh
   }
 
   return 0;
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void SignalProxy_Compare_gtk_callback_destroy(void* data)
+void SignalProxy_Compare::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::TreeSortable::SlotCompare*>(data);
+  delete static_cast<SignalProxy_Compare*>(data);
 }
 
+} // anonymous namespace
+
+
 namespace Gtk
 {
 
 void TreeSortable::set_sort_func(int sort_column_id, const SlotCompare& slot)
 {
-  SlotCompare* slot_copy = new SlotCompare(slot);
+  SignalProxy_Compare *const pSignalProxy = new SignalProxy_Compare(slot);
 
   gtk_tree_sortable_set_sort_func(
       gobj(), sort_column_id,
-      &SignalProxy_Compare_gtk_callback, slot_copy,
-      &SignalProxy_Compare_gtk_callback_destroy);
+      &SignalProxy_Compare::gtk_callback, pSignalProxy,
+      &SignalProxy_Compare::gtk_callback_destroy);
 }
 
 void TreeSortable::set_sort_func(const Gtk::TreeModelColumnBase& sort_column, const SlotCompare& slot)
@@ -70,12 +95,12 @@ void TreeSortable::set_sort_func(const Gtk::TreeModelColumnBase& sort_column, co
 
 void TreeSortable::set_default_sort_func(const SlotCompare& slot)
 {
-  SlotCompare* slot_copy = new SlotCompare(slot);
+  SignalProxy_Compare *const pSignalProxy = new SignalProxy_Compare(slot);
 
   gtk_tree_sortable_set_default_sort_func(
       gobj(),
-      &SignalProxy_Compare_gtk_callback, slot_copy,
-      &SignalProxy_Compare_gtk_callback_destroy);
+      &SignalProxy_Compare::gtk_callback, pSignalProxy,
+      &SignalProxy_Compare::gtk_callback_destroy);
 }
 
 void TreeSortable::unset_default_sort_func()
@@ -84,19 +109,17 @@ void TreeSortable::unset_default_sort_func()
       gobj(), 0, 0, 0); /* See GTK+ docs about the 0s. */
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+//deprecated:
 void TreeSortable::set_sort_column_id(const TreeModelColumnBase& sort_column, SortType order)
 {
   set_sort_column(sort_column, order);
 }
 
+//deprecated:
 void TreeSortable::set_sort_column_id(int sort_column_id, SortType order)
 {
   set_sort_column(sort_column_id, order);
 }  
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
 } // namespace Gtk
 
@@ -104,15 +127,13 @@ void TreeSortable::set_sort_column_id(int sort_column_id, SortType order)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo TreeSortable_signal_sort_column_changed_info =
+const Glib::SignalProxyInfo TreeSortable_signal_sort_column_changed_info =
 {
   "sort_column_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -157,21 +178,15 @@ void TreeSortable_Class::iface_init_function(void* g_iface, void*)
   //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
   g_assert(klass != 0); 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->get_sort_column_id = &get_sort_column_id_vfunc_callback;
   klass->set_sort_column_id = &set_sort_column_id_vfunc_callback;
   klass->set_sort_func = &set_sort_func_vfunc_callback;
   klass->set_default_sort_func = &set_default_sort_func_vfunc_callback;
   klass->has_default_sort_func = &has_default_sort_func_vfunc_callback;
   klass->sort_column_changed = &sort_column_changed_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->sort_column_changed = &sort_column_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 gboolean TreeSortable_Class::get_sort_column_id_vfunc_callback(GtkTreeSortable* self, int* sort_column_id, GtkSortType* order)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -184,20 +199,16 @@ gboolean TreeSortable_Class::get_sort_column_id_vfunc_callback(GtkTreeSortable*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->get_sort_column_id_vfunc(sort_column_id, ((SortType*) (order))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -214,6 +225,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 void TreeSortable_Class::set_sort_column_id_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkSortType order)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -226,20 +238,16 @@ void TreeSortable_Class::set_sort_column_id_vfunc_callback(GtkTreeSortable* self
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_sort_column_id_vfunc(sort_column_id, ((SortType)(order))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -253,6 +261,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_sort_column_id)(self, sort_column_id, order);
   }
 }
+
 void TreeSortable_Class::set_sort_func_vfunc_callback(GtkTreeSortable* self, int sort_column_id, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -265,20 +274,16 @@ void TreeSortable_Class::set_sort_func_vfunc_callback(GtkTreeSortable* self, int
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_sort_func_vfunc(sort_column_id, func, data
 , destroy);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -292,6 +297,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_sort_func)(self, sort_column_id, func, data, destroy);
   }
 }
+
 void TreeSortable_Class::set_default_sort_func_vfunc_callback(GtkTreeSortable* self, GtkTreeIterCompareFunc func, gpointer data, GtkDestroyNotify destroy)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -304,20 +310,16 @@ void TreeSortable_Class::set_default_sort_func_vfunc_callback(GtkTreeSortable* s
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->set_default_sort_func_vfunc(func, data
 , destroy);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -331,6 +333,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->set_default_sort_func)(self, func, data, destroy);
   }
 }
+
 gboolean TreeSortable_Class::has_default_sort_func_vfunc_callback(GtkTreeSortable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -343,19 +346,15 @@ gboolean TreeSortable_Class::has_default_sort_func_vfunc_callback(GtkTreeSortabl
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->has_default_sort_func_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -372,6 +371,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
   typedef gboolean RType;
   return RType();
 }
+
 void TreeSortable_Class::sort_column_changed_vfunc_callback(GtkTreeSortable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -384,19 +384,15 @@ void TreeSortable_Class::sort_column_changed_vfunc_callback(GtkTreeSortable* sel
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->sort_column_changed_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -410,9 +406,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->sort_column_changed)(self);
   }
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void TreeSortable_Class::sort_column_changed_callback(GtkTreeSortable* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -425,19 +420,15 @@ void TreeSortable_Class::sort_column_changed_callback(GtkTreeSortable* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_sort_column_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -451,7 +442,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(self), CppObjectType::get_type()) // Ge
       (*base->sort_column_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TreeSortable_Class::wrap_new(GObject* object)
@@ -501,12 +491,12 @@ bool TreeSortable::get_sort_column_id(int& sort_column_id, SortType& order) cons
 
 void TreeSortable::set_sort_column(const TreeModelColumnBase& sort_column_id, SortType order)
 {
-gtk_tree_sortable_set_sort_column_id(gobj(), (sort_column_id).index(), ((GtkSortType)(order))); 
+  gtk_tree_sortable_set_sort_column_id(gobj(), (sort_column_id).index(), ((GtkSortType)(order)));
 }
 
 void TreeSortable::set_sort_column(int sort_column_id, SortType order)
 {
-gtk_tree_sortable_set_sort_column_id(gobj(), sort_column_id, ((GtkSortType)(order))); 
+  gtk_tree_sortable_set_sort_column_id(gobj(), sort_column_id, ((GtkSortType)(order)));
 }
 
 bool TreeSortable::has_default_sort_func() const
@@ -516,7 +506,7 @@ bool TreeSortable::has_default_sort_func() const
 
 void TreeSortable::sort_column_changed()
 {
-gtk_tree_sortable_sort_column_changed(gobj()); 
+  gtk_tree_sortable_sort_column_changed(gobj());
 }
 
 
@@ -526,7 +516,6 @@ Glib::SignalProxy0< void > TreeSortable::signal_sort_column_changed()
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TreeSortable::on_sort_column_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -537,9 +526,8 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->sort_column_changed)
     (*base->sort_column_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 bool Gtk::TreeSortable::get_sort_column_id_vfunc(int* sort_column_id, SortType* order) const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -553,6 +541,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 void Gtk::TreeSortable::set_sort_column_id_vfunc(int sort_column_id, SortType order) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -563,6 +552,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_sort_column_id)
     (*base->set_sort_column_id)(gobj(),sort_column_id,((GtkSortType)(order)));
 }
+
 void Gtk::TreeSortable::set_sort_func_vfunc(int sort_column_id, GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -573,6 +563,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_sort_func)
     (*base->set_sort_func)(gobj(),sort_column_id,func,data,destroy);
 }
+
 void Gtk::TreeSortable::set_default_sort_func_vfunc(GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -583,6 +574,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->set_default_sort_func)
     (*base->set_default_sort_func)(gobj(),func,data,destroy);
 }
+
 bool Gtk::TreeSortable::has_default_sort_func_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -596,6 +588,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   typedef bool RType;
   return RType();
 }
+
 void Gtk::TreeSortable::sort_column_changed_vfunc() const
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -606,7 +599,6 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->sort_column_changed)
     (*base->sort_column_changed)(const_cast<GtkTreeSortable*>(gobj()));
 }
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/treesortable.h b/libs/gtkmm2/gtk/gtkmm/treesortable.h
index 514d4181b7..6b295a1f41 100644
--- a/libs/gtkmm2/gtk/gtkmm/treesortable.h
+++ b/libs/gtkmm2/gtk/gtkmm/treesortable.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREESORTABLE_H
 #define _GTKMM_TREESORTABLE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -136,7 +135,6 @@ public:
   void set_sort_column(int sort_column_id, SortType order);
 
   #ifndef GTKMM_DISABLE_DEPRECATED
-
   /** @deprecated Use set_sort_column() instead.
    */
   void set_sort_column_id(const TreeModelColumnBase& sort_column_id, SortType order);
@@ -144,10 +142,9 @@ public:
   /** @deprecated Use set_sort_column() instead.
    */
   void set_sort_column_id(int sort_column_id, SortType order);
-  #endif // GTKMM_DISABLE_DEPRECATED
-
+  #endif //GTKMM_DISABLE_DEPRECATED
 
-  /** This callback should return -1 if a compares before b, 0 if they compare equal, 1 if a compares after b. 
+  /** This callback should return -1 if b compares before a, 0 if they compare equal, 1 if a compares after b. 
    * For instance, int on_sort_compare(const Gtk::TreeModel::iterator& a, const Gtk::TreeModel::iterator& b);
    */
   typedef sigc::slot<int, const Gtk::TreeModel::iterator&, const Gtk::TreeModel::iterator&> SlotCompare;
@@ -196,56 +193,29 @@ public:
    */
   void sort_column_changed();
   
-/**
-   * @par Prototype:
-   * <tt>void %sort_column_changed()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_sort_column_changed();
 
 
 protected:
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool get_sort_column_id_vfunc(int* sort_column_id, SortType* order) const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_sort_column_id_vfunc(int sort_column_id, SortType order);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_sort_func_vfunc(int sort_column_id, GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void set_default_sort_func_vfunc(GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual bool has_default_sort_func_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void sort_column_changed_vfunc() const;
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual bool get_sort_column_id_vfunc(int* sort_column_id, SortType* order) const;
+    virtual void set_sort_column_id_vfunc(int sort_column_id, SortType order);
+    virtual void set_sort_func_vfunc(int sort_column_id, GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy);
+    virtual void set_default_sort_func_vfunc(GtkTreeIterCompareFunc func, void* data, GtkDestroyNotify destroy);
+    virtual bool has_default_sort_func_vfunc() const;
+    virtual void sort_column_changed_vfunc() const;
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_sort_column_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
@@ -264,6 +234,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _GTKMM_TREESORTABLE_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treestore.cc b/libs/gtkmm2/gtk/gtkmm/treestore.cc
index e38fdeb739..cddd5961eb 100644
--- a/libs/gtkmm2/gtk/gtkmm/treestore.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treestore.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treestore.h>
 #include <gtkmm/private/treestore_p.h>
 
@@ -198,19 +197,8 @@ void TreeStore_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* TreeStore_Class::wrap_new(GObject* object)
 {
@@ -266,12 +254,12 @@ Glib::RefPtr<TreeStore> TreeStore::create(const TreeModelColumnRecord& columns)
 }
 void TreeStore::iter_swap(const iterator& a, const iterator& b)
 {
-gtk_tree_store_swap(gobj(), const_cast<GtkTreeIter*>((a).gobj()), const_cast<GtkTreeIter*>((b).gobj())); 
+  gtk_tree_store_swap(gobj(), const_cast<GtkTreeIter*>((a).gobj()), const_cast<GtkTreeIter*>((b).gobj()));
 }
 
 void TreeStore::clear()
 {
-gtk_tree_store_clear(gobj()); 
+  gtk_tree_store_clear(gobj());
 }
 
 bool TreeStore::is_ancestor(const iterator& iter, const iterator& descendant) const
@@ -290,13 +278,6 @@ bool TreeStore::iter_is_valid(const iterator& iter) const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Gtk
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treestore.h b/libs/gtkmm2/gtk/gtkmm/treestore.h
index d947c7a2ca..e5d01a4443 100644
--- a/libs/gtkmm2/gtk/gtkmm/treestore.h
+++ b/libs/gtkmm2/gtk/gtkmm/treestore.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREESTORE_H
 #define _GTKMM_TREESTORE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -191,7 +190,7 @@ public:
   /** Swaps @a a  and @a b  in the same level of @a tree_store . Note that this function
    * only works with unsorted stores.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param a A Gtk::TreeIter.
    * @param b Another Gtk::TreeIter.
    */
@@ -238,7 +237,7 @@ public:
    * @param iter A Gtk::TreeIter.
    * @return <tt>true</tt> if the iter is valid, <tt>false</tt> if the iter is invalid.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool iter_is_valid(const iterator& iter) const;
 
@@ -250,17 +249,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview.cc b/libs/gtkmm2/gtk/gtkmm/treeview.cc
index e43f7a2df9..4337e88c50 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeview.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treeview.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treeview.h>
 #include <gtkmm/private/treeview_p.h>
 
@@ -25,51 +24,98 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <gtk/gtktreeview.h>
 #include <gtkmm/treeviewcolumn.h>
 #include <gtkmm/treeview_private.h>
 #include <gtkmm/treemodel.h>
 #include <gtkmm/treemodelfilter.h>
-#include <gtkmm/entry.h>
-#include <gtk/gtktreeview.h>
 
 namespace
 {
 
 //This target name is used in the GTK+ implementation:
-static const char treeview_target_row[]   = "GTK_TREE_MODEL_ROW";
+const char treeview_target_row[]   = "GTK_TREE_MODEL_ROW";
 
 } // anonymous namespace
 
+namespace
+{
+
+//SignalProxy_Mapping:
 
-static void SignalProxy_Mapping_gtk_callback(GtkTreeView* tree_view, GtkTreePath* path, void* data)
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_Mapping
 {
-  Gtk::TreeView::SlotMapping* the_slot = static_cast<Gtk::TreeView::SlotMapping*>(data);
+public:
+  typedef Gtk::TreeView::SlotMapping SlotType;
+
+  SignalProxy_Mapping(const SlotType& slot);
+  ~SignalProxy_Mapping();
+
+  static void gtk_callback(GtkTreeView* tree_view, GtkTreePath* path, void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_Mapping::SignalProxy_Mapping(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_Mapping::~SignalProxy_Mapping()
+{}
+
+void SignalProxy_Mapping::gtk_callback(GtkTreeView* tree_view, GtkTreePath* path, void* data)
+{
+  SignalProxy_Mapping *const self = static_cast<SignalProxy_Mapping*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    (*the_slot)(Glib::wrap(tree_view), Gtk::TreePath(path, true));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)(Glib::wrap(tree_view), Gtk::TreePath(path, true));
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static gboolean SignalProxy_SearchEqual_gtk_callback(GtkTreeModel* model, int column, const char* key,
+
+//SignalProxy_SearchEqual:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_SearchEqual
+{
+public:
+  typedef Gtk::TreeView::SlotSearchEqual SlotType;
+
+  SignalProxy_SearchEqual(const SlotType& slot);
+  ~SignalProxy_SearchEqual();
+
+  static gboolean gtk_callback(GtkTreeModel* model, int column, const char* key,
+                               GtkTreeIter* iter, void* data);
+  static void gtk_callback_destroy(void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_SearchEqual::SignalProxy_SearchEqual(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_SearchEqual::~SignalProxy_SearchEqual()
+{}
+
+gboolean SignalProxy_SearchEqual::gtk_callback(GtkTreeModel* model, int column, const char* key,
                                                GtkTreeIter* iter, void* data)
 {
-  Gtk::TreeView::SlotSearchEqual* the_slot = static_cast<Gtk::TreeView::SlotSearchEqual*>(data);
+  SignalProxy_SearchEqual *const self = static_cast<SignalProxy_SearchEqual*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    return (*the_slot)(Glib::wrap(model, true), column, key, Gtk::TreeIter(model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    return (self->slot_)(Glib::wrap(model, true), column, key, Gtk::TreeIter(model, iter));
   }
   catch(...)
   {
@@ -77,65 +123,68 @@ static gboolean SignalProxy_SearchEqual_gtk_callback(GtkTreeModel* model, int co
   }
 
   return 0; // arbitrary value
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
-static void SignalProxy_SearchEqual_gtk_callback_destroy(void* data)
+void SignalProxy_SearchEqual::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::TreeView::SlotSearchEqual*>(data);
+  delete static_cast<SignalProxy_SearchEqual*>(data);
 }
 
-static gboolean SignalProxy_ColumnDrop_gtk_callback(GtkTreeView* tree_view, GtkTreeViewColumn* column,
+
+//SignalProxy_ColumnDrop:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_ColumnDrop
+{
+public:
+  typedef Gtk::TreeView::SlotColumnDrop SlotType;
+
+  SignalProxy_ColumnDrop(const SlotType& slot);
+  ~SignalProxy_ColumnDrop();
+
+  static gboolean gtk_callback(GtkTreeView* tree_view, GtkTreeViewColumn* column,
+                               GtkTreeViewColumn* prev_column, GtkTreeViewColumn* next_column,
+                               void* data);
+  static void gtk_callback_destroy(void* data);
+
+protected:
+  SlotType slot_;
+};
+
+SignalProxy_ColumnDrop::SignalProxy_ColumnDrop(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_ColumnDrop::~SignalProxy_ColumnDrop()
+{}
+
+gboolean SignalProxy_ColumnDrop::gtk_callback(GtkTreeView* tree_view, GtkTreeViewColumn* column,
                                               GtkTreeViewColumn* prev_column,
                                               GtkTreeViewColumn* next_column, void* data)
 {
-  Gtk::TreeView::SlotColumnDrop* the_slot = static_cast<Gtk::TreeView::SlotColumnDrop*>(data);
+  SignalProxy_ColumnDrop *const self = static_cast<SignalProxy_ColumnDrop*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    return (*the_slot)(Glib::wrap(tree_view), Glib::wrap(column),
+    return (self->slot_)(Glib::wrap(tree_view), Glib::wrap(column),
                          Glib::wrap(prev_column), Glib::wrap(next_column));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 
   return 0; // arbitrary value
 }
 
-static void SignalProxy_ColumnDrop_gtk_callback_destroy(void* data)
+void SignalProxy_ColumnDrop::gtk_callback_destroy(void* data)
 {
-  delete static_cast<Gtk::TreeView::SlotColumnDrop*>(data);
+  delete static_cast<SignalProxy_ColumnDrop*>(data);
 }
 
+} // anonymous namespace
 
-static void SignalProxy_SearchPosition_gtk_callback(GtkTreeView* /* tree_view */, GtkWidget* search_dialog, gpointer user_data)
-{
-  Gtk::TreeView::SlotSearchPosition* the_slot = static_cast<Gtk::TreeView::SlotSearchPosition*>(user_data);
-
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  try
-  {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-    (*the_slot)(Glib::wrap(search_dialog));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  }
-  catch(...)
-  {
-    Glib::exception_handlers_invoke();
-  }
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
-}
-
-static void SignalProxy_SearchPosition_gtk_callback_destroy(void* data)
-{
-  delete static_cast<Gtk::TreeView::SlotSearchPosition*>(data);
-}
 
 namespace Gtk
 {
@@ -152,14 +201,15 @@ void TreeView::unset_vadjustment()
 
 int TreeView::insert_column_with_data_func(int position, const Glib::ustring& title, CellRenderer& cell, const SlotCellData& slot)
 {
-  //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  //It will be deleted when TreeView_Private::SignalProxy_CellData_gtk_callback_destroy() is called.
-  SlotCellData* slot_copy = new SlotCellData(slot);
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when TreeView_Private::SignalProxy_CellData::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_CellData *const pSignalProxy =
+      new TreeView_Private::SignalProxy_CellData(slot);
 
   return gtk_tree_view_insert_column_with_data_func(
       gobj(), position, title.c_str(), cell.gobj(),
-      &TreeView_Private::SignalProxy_CellData_gtk_callback, slot_copy,
-      &TreeView_Private::SignalProxy_CellData_gtk_callback_destroy);
+      &TreeView_Private::SignalProxy_CellData::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_CellData::gtk_callback_destroy);
 }
 
 void TreeView::set_cursor(const TreeModel::Path& path)
@@ -207,8 +257,6 @@ void TreeView::enable_model_drag_dest(Gdk::DragAction actions)
   enable_model_drag_dest(listTargets, actions);
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 bool TreeView::get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y)
 {
   GtkTreePath* pTreePath = 0;
@@ -219,19 +267,6 @@ bool TreeView::get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColu
   column = Glib::wrap(pTreeViewColumn);
   return result;
 }
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-bool TreeView::get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y) const
-{
-  GtkTreePath* pTreePath = 0;
-  GtkTreeViewColumn* pTreeViewColumn = 0;
-  bool result = gtk_tree_view_get_path_at_pos(const_cast<GtkTreeView*>(gobj()), x, y, &pTreePath, &pTreeViewColumn, &cell_x, &cell_y);
-
-  path = TreeModel::Path(pTreePath, false /* don't take a copy, because the gtk_tree_view_get_path_at_pos() docs say that we must free the path */ );
-  column = Glib::wrap(pTreeViewColumn);
-  return result;
-}
 
 int TreeView::insert_column(const Glib::ustring& title, CellRenderer& cell, int position)
 {
@@ -263,29 +298,32 @@ bool TreeView::get_dest_row_at_pos(int drag_x, int drag_y, TreeModel::Path& path
 
 void TreeView::map_expanded_rows(const SlotMapping& slot)
 {
-  gtk_tree_view_map_expanded_rows(gobj(), &SignalProxy_Mapping_gtk_callback, const_cast<SlotMapping*>(&slot));
+  //Create a signal proxy.
+  SignalProxy_Mapping signalProxy (slot); //It only needs to live as long as this method call.
+
+  gtk_tree_view_map_expanded_rows(gobj(), &SignalProxy_Mapping::gtk_callback, &signalProxy);
 }
 
 void TreeView::set_search_equal_func(const SlotSearchEqual& slot)
 {
-  //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  //It will be deleted when SignalProxy_SearchEqual_gtk_callback_destroy() is called.
-  SlotSearchEqual* slot_copy = new SlotSearchEqual(slot);
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_SearchEqual::gtk_callback_destroy() is called.
+  SignalProxy_SearchEqual *const pSignalProxy = new SignalProxy_SearchEqual(slot);
 
   gtk_tree_view_set_search_equal_func(gobj(),
-      &SignalProxy_SearchEqual_gtk_callback, slot_copy,
-      &SignalProxy_SearchEqual_gtk_callback_destroy);
+      &SignalProxy_SearchEqual::gtk_callback, pSignalProxy,
+      &SignalProxy_SearchEqual::gtk_callback_destroy);
 }
 
 void TreeView::set_column_drag_function(const SlotColumnDrop& slot)
 {
-  //Create a copt of the slot. A pointer to this will be passed through the callback's data parameter.
-  //It will be deleted when SignalProxy_ColumnDrop_gtk_callback_destroy() is called.
-   SlotColumnDrop* slot_copy = new SlotColumnDrop(slot);
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_ColumnDrop::gtk_callback_destroy() is called.
+  SignalProxy_ColumnDrop *const pSignalProxy = new SignalProxy_ColumnDrop(slot);
 
   gtk_tree_view_set_column_drag_function(gobj(),
-      &SignalProxy_ColumnDrop_gtk_callback, slot_copy,
-      &SignalProxy_ColumnDrop_gtk_callback_destroy);
+      &SignalProxy_ColumnDrop::gtk_callback, pSignalProxy,
+      &SignalProxy_ColumnDrop::gtk_callback_destroy);
 
 }
 
@@ -383,22 +421,16 @@ Glib::RefPtr<Gtk::TreeModel> TreeView::_get_base_model()
 void TreeView::_auto_store_on_cellrenderer_toggle_edited(const Glib::ustring& path_string,
                                                          int model_column)
 {
-  _auto_store_on_cellrenderer_toggle_edited_with_model(path_string, model_column, _get_base_model());
-}
-
-void TreeView::_auto_store_on_cellrenderer_toggle_edited_with_model(const Glib::ustring& path_string,
-                                                         int model_column, const Glib::RefPtr<Gtk::TreeModel>& model)
-{
   Gtk::TreePath path (path_string);
 
   //Get the row from the path:
-  if(model)
+  Glib::RefPtr<TreeModel> refModel = _get_base_model();
+
+  Gtk::TreeModel::iterator iter = refModel->get_iter(path);
+  if(iter)
   {
-    Gtk::TreeModel::iterator iter = model->get_iter(path);
-    if(iter)
-    {
       Gtk::TreeRow row = *iter;
-
+      
       //Get the new value:
       //This seems to get the old value, not the new one,
       //so we will just NOT the model value ourselves.
@@ -406,10 +438,9 @@ void TreeView::_auto_store_on_cellrenderer_toggle_edited_with_model(const Glib::
       bool bActive = false;
       row.get_value(model_column, bActive);
       bActive = !bActive;
-
-      //Store the user's new text in the model:
+      
+      //Store the user's new text in the model: 
       row.set_value(model_column, bActive);
-    }
   }
 }
 
@@ -420,40 +451,13 @@ void TreeView::move_column_to_start(TreeViewColumn& column)
 
 void TreeView::set_row_separator_func(const SlotRowSeparator& slot)
 {
-  //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  //It will be deleted when SignalProxy_RowSeparator_gtk_callback_destroy() is called.
-  SlotRowSeparator* slot_copy = new SlotRowSeparator(slot);
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when SignalProxy_RowSeparator::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_RowSeparator *const pSignalProxy = new TreeView_Private::SignalProxy_RowSeparator(slot);
 
   gtk_tree_view_set_row_separator_func(gobj(),
-      &TreeView_Private::SignalProxy_RowSeparator_gtk_callback, slot_copy,
-      &TreeView_Private::SignalProxy_RowSeparator_gtk_callback_destroy);
-}
-
-void TreeView::set_search_position_func(const SlotSearchPosition& slot)
-{
-  //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  //It will be deleted when SignalProxy_SearchPosition_gtk_callback_destroy() is called.
-  SlotSearchPosition* slot_copy = new SlotSearchPosition(slot);
-
-  gtk_tree_view_set_search_position_func(gobj(),
-      &SignalProxy_SearchPosition_gtk_callback, slot_copy,
-      &SignalProxy_SearchPosition_gtk_callback_destroy);
-}
-
-bool TreeView::get_visible_range(TreeModel::Path& start_path, TreeModel::Path& end_path) const
-{
-  GtkTreePath* pTreePathStart = 0;
-  GtkTreePath* pTreePathEnd = 0;
-  bool result = gtk_tree_view_get_visible_range(const_cast<GtkTreeView*>(gobj()), &pTreePathStart, &pTreePathEnd);
-
-  start_path = TreeModel::Path(pTreePathStart, false /* don't take a copy, because the gtk_tree_view_get_visible_range() docs say that we must free the path */ );
-  end_path = TreeModel::Path(pTreePathEnd, false /* don't take a copy, because the gtk_tree_view_get_visible_range() docs say that we must free the path */ );
-  return result;
-}
-
-void TreeView::unset_model()
-{
-  gtk_tree_view_set_model(gobj(), 0);
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_RowSeparator::gtk_callback_destroy);
 }
 
 } // namespace Gtk
@@ -462,8 +466,7 @@ void TreeView::unset_model()
 namespace
 {
 
-
-static void TreeView_signal_set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+void TreeView_signal_set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Adjustment*,Adjustment* > SlotType;
@@ -471,25 +474,21 @@ static void TreeView_signal_set_scroll_adjustments_callback(GtkTreeView* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeView_signal_set_scroll_adjustments_info =
+const Glib::SignalProxyInfo TreeView_signal_set_scroll_adjustments_info =
 {
   "set-scroll-adjustments",
   (GCallback) &TreeView_signal_set_scroll_adjustments_callback,
@@ -497,7 +496,7 @@ static const Glib::SignalProxyInfo TreeView_signal_set_scroll_adjustments_info =
 };
 
 
-static void TreeView_signal_row_activated_callback(GtkTreeView* self, GtkTreePath* p0,GtkTreeViewColumn* p1,void* data)
+void TreeView_signal_row_activated_callback(GtkTreeView* self, GtkTreePath* p0,GtkTreeViewColumn* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::Path&,TreeViewColumn* > SlotType;
@@ -505,25 +504,21 @@ static void TreeView_signal_row_activated_callback(GtkTreeView* self, GtkTreePat
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Gtk::TreePath(p0, true)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeView_signal_row_activated_info =
+const Glib::SignalProxyInfo TreeView_signal_row_activated_info =
 {
   "row-activated",
   (GCallback) &TreeView_signal_row_activated_callback,
@@ -531,7 +526,7 @@ static const Glib::SignalProxyInfo TreeView_signal_row_activated_info =
 };
 
 
-static gboolean TreeView_signal_test_expand_row_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+gboolean TreeView_signal_test_expand_row_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
@@ -539,28 +534,24 @@ static gboolean TreeView_signal_test_expand_row_callback(GtkTreeView* self, GtkT
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean TreeView_signal_test_expand_row_notify_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1, void* data)
+gboolean TreeView_signal_test_expand_row_notify_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
@@ -568,28 +559,24 @@ static gboolean TreeView_signal_test_expand_row_notify_callback(GtkTreeView* sel
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo TreeView_signal_test_expand_row_info =
+const Glib::SignalProxyInfo TreeView_signal_test_expand_row_info =
 {
   "test-expand-row",
   (GCallback) &TreeView_signal_test_expand_row_callback,
@@ -597,7 +584,7 @@ static const Glib::SignalProxyInfo TreeView_signal_test_expand_row_info =
 };
 
 
-static gboolean TreeView_signal_test_collapse_row_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+gboolean TreeView_signal_test_collapse_row_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
@@ -605,28 +592,24 @@ static gboolean TreeView_signal_test_collapse_row_callback(GtkTreeView* self, Gt
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean TreeView_signal_test_collapse_row_notify_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1, void* data)
+gboolean TreeView_signal_test_collapse_row_notify_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
@@ -634,28 +617,24 @@ static gboolean TreeView_signal_test_collapse_row_notify_callback(GtkTreeView* s
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo TreeView_signal_test_collapse_row_info =
+const Glib::SignalProxyInfo TreeView_signal_test_collapse_row_info =
 {
   "test-collapse-row",
   (GCallback) &TreeView_signal_test_collapse_row_callback,
@@ -663,7 +642,7 @@ static const Glib::SignalProxyInfo TreeView_signal_test_collapse_row_info =
 };
 
 
-static void TreeView_signal_row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+void TreeView_signal_row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
@@ -671,25 +650,21 @@ static void TreeView_signal_row_expanded_callback(GtkTreeView* self, GtkTreeIter
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeView_signal_row_expanded_info =
+const Glib::SignalProxyInfo TreeView_signal_row_expanded_info =
 {
   "row-expanded",
   (GCallback) &TreeView_signal_row_expanded_callback,
@@ -697,7 +672,7 @@ static const Glib::SignalProxyInfo TreeView_signal_row_expanded_info =
 };
 
 
-static void TreeView_signal_row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
+void TreeView_signal_row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0,GtkTreePath* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const TreeModel::iterator&,const TreeModel::Path& > SlotType;
@@ -705,25 +680,21 @@ static void TreeView_signal_row_collapsed_callback(GtkTreeView* self, GtkTreeIte
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo TreeView_signal_row_collapsed_info =
+const Glib::SignalProxyInfo TreeView_signal_row_collapsed_info =
 {
   "row-collapsed",
   (GCallback) &TreeView_signal_row_collapsed_callback,
@@ -731,7 +702,7 @@ static const Glib::SignalProxyInfo TreeView_signal_row_collapsed_info =
 };
 
 
-static const Glib::SignalProxyInfo TreeView_signal_cursor_changed_info =
+const Glib::SignalProxyInfo TreeView_signal_cursor_changed_info =
 {
   "cursor-changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -739,14 +710,13 @@ static const Glib::SignalProxyInfo TreeView_signal_cursor_changed_info =
 };
 
 
-static const Glib::SignalProxyInfo TreeView_signal_columns_changed_info =
+const Glib::SignalProxyInfo TreeView_signal_columns_changed_info =
 {
   "columns-changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -755,12 +725,6 @@ GType Glib::Value<Gtk::TreeViewDropPosition>::value_type()
   return gtk_tree_view_drop_position_get_type();
 }
 
-// static
-GType Glib::Value<Gtk::TreeViewGridLines>::value_type()
-{
-  return gtk_tree_view_grid_lines_get_type();
-}
-
 
 namespace Glib
 {
@@ -803,10 +767,6 @@ void TreeView_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
   klass->row_activated = &row_activated_callback;
   klass->test_expand_row = &test_expand_row_callback;
@@ -815,13 +775,9 @@ void TreeView_Class::class_init_function(void* g_class, void* class_data)
   klass->row_collapsed = &row_collapsed_callback;
   klass->cursor_changed = &cursor_changed_callback;
   klass->columns_changed = &columns_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void TreeView_Class::set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjustment* p0, GtkAdjustment* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -834,21 +790,17 @@ void TreeView_Class::set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjus
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_scroll_adjustments(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -861,6 +813,7 @@ void TreeView_Class::set_scroll_adjustments_callback(GtkTreeView* self, GtkAdjus
       (*base->set_scroll_adjustments)(self, p0, p1);
   }
 }
+
 void TreeView_Class::row_activated_callback(GtkTreeView* self, GtkTreePath* p0, GtkTreeViewColumn* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -873,21 +826,17 @@ void TreeView_Class::row_activated_callback(GtkTreeView* self, GtkTreePath* p0,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_activated(Gtk::TreePath(p0, true)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -900,6 +849,7 @@ void TreeView_Class::row_activated_callback(GtkTreeView* self, GtkTreePath* p0,
       (*base->row_activated)(self, p0, p1);
   }
 }
+
 gboolean TreeView_Class::test_expand_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -912,21 +862,17 @@ gboolean TreeView_Class::test_expand_row_callback(GtkTreeView* self, GtkTreeIter
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_test_expand_row(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -942,6 +888,7 @@ gboolean TreeView_Class::test_expand_row_callback(GtkTreeView* self, GtkTreeIter
   typedef gboolean RType;
   return RType();
 }
+
 gboolean TreeView_Class::test_collapse_row_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -954,21 +901,17 @@ gboolean TreeView_Class::test_collapse_row_callback(GtkTreeView* self, GtkTreeIt
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_test_collapse_row(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -984,6 +927,7 @@ gboolean TreeView_Class::test_collapse_row_callback(GtkTreeView* self, GtkTreeIt
   typedef gboolean RType;
   return RType();
 }
+
 void TreeView_Class::row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -996,21 +940,17 @@ void TreeView_Class::row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0, G
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_expanded(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1023,6 +963,7 @@ void TreeView_Class::row_expanded_callback(GtkTreeView* self, GtkTreeIter* p0, G
       (*base->row_expanded)(self, p0, p1);
   }
 }
+
 void TreeView_Class::row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0, GtkTreePath* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1035,21 +976,17 @@ void TreeView_Class::row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_row_collapsed(TreeModel::iterator(gtk_tree_view_get_model(self), p0)
 , Gtk::TreePath(p1, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1062,6 +999,7 @@ void TreeView_Class::row_collapsed_callback(GtkTreeView* self, GtkTreeIter* p0,
       (*base->row_collapsed)(self, p0, p1);
   }
 }
+
 void TreeView_Class::cursor_changed_callback(GtkTreeView* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1074,19 +1012,15 @@ void TreeView_Class::cursor_changed_callback(GtkTreeView* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_cursor_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1099,6 +1033,7 @@ void TreeView_Class::cursor_changed_callback(GtkTreeView* self)
       (*base->cursor_changed)(self);
   }
 }
+
 void TreeView_Class::columns_changed_callback(GtkTreeView* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -1111,19 +1046,15 @@ void TreeView_Class::columns_changed_callback(GtkTreeView* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_columns_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -1136,7 +1067,6 @@ void TreeView_Class::columns_changed_callback(GtkTreeView* self)
       (*base->columns_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TreeView_Class::wrap_new(GObject* o)
@@ -1196,40 +1126,45 @@ Glib::RefPtr<TreeModel> TreeView::get_model()
 {
 
   Glib::RefPtr<TreeModel> retvalue = Glib::wrap(gtk_tree_view_get_model(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TreeModel> TreeView::get_model() const
 {
 
   Glib::RefPtr<const TreeModel> retvalue = Glib::wrap(gtk_tree_view_get_model(const_cast<GtkTreeView*>(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 void TreeView::set_model(const Glib::RefPtr<TreeModel>& model)
 {
-gtk_tree_view_set_model(gobj(), Glib::unwrap(model)); 
+  gtk_tree_view_set_model(gobj(), Glib::unwrap(model));
 }
 
 Glib::RefPtr<TreeSelection> TreeView::get_selection()
 {
 
   Glib::RefPtr<TreeSelection> retvalue = Glib::wrap(gtk_tree_view_get_selection(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TreeSelection> TreeView::get_selection() const
 {
-  return const_cast<TreeView*>(this)->get_selection();
+
+  Glib::RefPtr<const TreeSelection> retvalue = Glib::wrap(gtk_tree_view_get_selection(const_cast<GtkTreeView*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Adjustment* TreeView::get_hadjustment()
@@ -1239,12 +1174,12 @@ Adjustment* TreeView::get_hadjustment()
 
 const Adjustment* TreeView::get_hadjustment() const
 {
-  return const_cast<TreeView*>(this)->get_hadjustment();
+  return Glib::wrap(gtk_tree_view_get_hadjustment(const_cast<GtkTreeView*>(gobj())));
 }
 
 void TreeView::set_hadjustment(Adjustment& adjustment)
 {
-gtk_tree_view_set_hadjustment(gobj(), (adjustment).gobj()); 
+  gtk_tree_view_set_hadjustment(gobj(), (adjustment).gobj());
 }
 
 Adjustment* TreeView::get_vadjustment()
@@ -1254,12 +1189,12 @@ Adjustment* TreeView::get_vadjustment()
 
 const Adjustment* TreeView::get_vadjustment() const
 {
-  return const_cast<TreeView*>(this)->get_vadjustment();
+  return Glib::wrap(gtk_tree_view_get_vadjustment(const_cast<GtkTreeView*>(gobj())));
 }
 
 void TreeView::set_vadjustment(Adjustment& adjustment)
 {
-gtk_tree_view_set_vadjustment(gobj(), (adjustment).gobj()); 
+  gtk_tree_view_set_vadjustment(gobj(), (adjustment).gobj());
 }
 
 bool TreeView::get_headers_visible() const
@@ -1269,27 +1204,22 @@ bool TreeView::get_headers_visible() const
 
 void TreeView::set_headers_visible(bool headers_visible)
 {
-gtk_tree_view_set_headers_visible(gobj(), static_cast<int>(headers_visible)); 
+  gtk_tree_view_set_headers_visible(gobj(), static_cast<int>(headers_visible));
 }
 
 void TreeView::columns_autosize()
 {
-gtk_tree_view_columns_autosize(gobj()); 
-}
-
-bool TreeView::get_headers_clickable() const
-{
-  return gtk_tree_view_get_headers_clickable(const_cast<GtkTreeView*>(gobj()));
+  gtk_tree_view_columns_autosize(gobj());
 }
 
 void TreeView::set_headers_clickable(bool setting)
 {
-gtk_tree_view_set_headers_clickable(gobj(), static_cast<int>(setting)); 
+  gtk_tree_view_set_headers_clickable(gobj(), static_cast<int>(setting));
 }
 
 void TreeView::set_rules_hint(bool setting)
 {
-gtk_tree_view_set_rules_hint(gobj(), static_cast<int>(setting)); 
+  gtk_tree_view_set_rules_hint(gobj(), static_cast<int>(setting));
 }
 
 bool TreeView::get_rules_hint() const
@@ -1319,7 +1249,7 @@ TreeViewColumn* TreeView::get_column(int n)
 
 const TreeViewColumn* TreeView::get_column(int n) const
 {
-  return const_cast<TreeView*>(this)->get_column(n);
+  return Glib::wrap(gtk_tree_view_get_column(const_cast<GtkTreeView*>(gobj()), n));
 }
 
 Glib::ListHandle<TreeViewColumn*> TreeView::get_columns()
@@ -1334,12 +1264,12 @@ Glib::ListHandle<const TreeViewColumn*> TreeView::get_columns() const
 
 void TreeView::move_column_after(TreeViewColumn& column, TreeViewColumn& base_column)
 {
-gtk_tree_view_move_column_after(gobj(), (column).gobj(), (base_column).gobj()); 
+  gtk_tree_view_move_column_after(gobj(), (column).gobj(), (base_column).gobj());
 }
 
 void TreeView::set_expander_column(TreeViewColumn& column)
 {
-gtk_tree_view_set_expander_column(gobj(), (column).gobj()); 
+  gtk_tree_view_set_expander_column(gobj(), (column).gobj());
 }
 
 TreeViewColumn* TreeView::get_expander_column()
@@ -1349,32 +1279,32 @@ TreeViewColumn* TreeView::get_expander_column()
 
 const TreeViewColumn* TreeView::get_expander_column() const
 {
-  return const_cast<TreeView*>(this)->get_expander_column();
+  return Glib::wrap(gtk_tree_view_get_expander_column(const_cast<GtkTreeView*>(gobj())));
 }
 
 void TreeView::scroll_to_point(int tree_x, int tree_y)
 {
-gtk_tree_view_scroll_to_point(gobj(), tree_x, tree_y); 
+  gtk_tree_view_scroll_to_point(gobj(), tree_x, tree_y);
 }
 
 void TreeView::row_activated(const TreeModel::Path& path, TreeViewColumn& column)
 {
-gtk_tree_view_row_activated(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj()); 
+  gtk_tree_view_row_activated(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj());
 }
 
 void TreeView::expand_all()
 {
-gtk_tree_view_expand_all(gobj()); 
+  gtk_tree_view_expand_all(gobj());
 }
 
 void TreeView::collapse_all()
 {
-gtk_tree_view_collapse_all(gobj()); 
+  gtk_tree_view_collapse_all(gobj());
 }
 
 void TreeView::expand_to_path(const TreeModel::Path& path)
 {
-gtk_tree_view_expand_to_path(gobj(), const_cast<GtkTreePath*>((path).gobj())); 
+  gtk_tree_view_expand_to_path(gobj(), const_cast<GtkTreePath*>((path).gobj()));
 }
 
 bool TreeView::expand_row(const TreeModel::Path& path, bool open_all)
@@ -1394,7 +1324,7 @@ bool TreeView::row_expanded(const TreeModel::Path& path)
 
 void TreeView::set_reorderable(bool reorderable)
 {
-gtk_tree_view_set_reorderable(gobj(), static_cast<int>(reorderable)); 
+  gtk_tree_view_set_reorderable(gobj(), static_cast<int>(reorderable));
 }
 
 bool TreeView::get_reorderable() const
@@ -1404,112 +1334,72 @@ bool TreeView::get_reorderable() const
 
 void TreeView::set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, bool start_editing)
 {
-gtk_tree_view_set_cursor(gobj(), const_cast<GtkTreePath*>((path).gobj()), (focus_column).gobj(), static_cast<int>(start_editing)); 
+  gtk_tree_view_set_cursor(gobj(), const_cast<GtkTreePath*>((path).gobj()), (focus_column).gobj(), static_cast<int>(start_editing));
 }
 
 void TreeView::set_cursor(const TreeModel::Path& path, TreeViewColumn& focus_column, CellRenderer& focus_cell, bool start_editing)
 {
-gtk_tree_view_set_cursor_on_cell(gobj(), const_cast<GtkTreePath*>((path).gobj()), (focus_column).gobj(), (focus_cell).gobj(), static_cast<int>(start_editing)); 
+  gtk_tree_view_set_cursor_on_cell(gobj(), const_cast<GtkTreePath*>((path).gobj()), (focus_column).gobj(), (focus_cell).gobj(), static_cast<int>(start_editing));
 }
 
 Glib::RefPtr<Gdk::Window> TreeView::get_bin_window()
 {
 
   Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_tree_view_get_bin_window(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Window> TreeView::get_bin_window() const
 {
-  return const_cast<TreeView*>(this)->get_bin_window();
-}
 
-#ifndef GTKMM_DISABLE_DEPRECATED
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_tree_view_get_bin_window(const_cast<GtkTreeView*>(gobj()))));
 
-void TreeView::get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect)
-{
-gtk_tree_view_get_cell_area(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj()); 
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-void TreeView::get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect) const
+void TreeView::get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect)
 {
-gtk_tree_view_get_cell_area(const_cast<GtkTreeView*>(gobj()), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj()); 
+  gtk_tree_view_get_cell_area(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj());
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void TreeView::get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect)
 {
-gtk_tree_view_get_background_area(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj()); 
+  gtk_tree_view_get_background_area(gobj(), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj());
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-void TreeView::get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect) const
-{
-gtk_tree_view_get_background_area(const_cast<GtkTreeView*>(gobj()), const_cast<GtkTreePath*>((path).gobj()), (column).gobj(), (rect).gobj()); 
-}
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void TreeView::get_visible_rect(Gdk::Rectangle& visible_rect)
 {
-gtk_tree_view_get_visible_rect(gobj(), (visible_rect).gobj()); 
+  gtk_tree_view_get_visible_rect(gobj(), (visible_rect).gobj());
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-void TreeView::get_visible_rect(Gdk::Rectangle& visible_rect) const
-{
-gtk_tree_view_get_visible_rect(const_cast<GtkTreeView*>(gobj()), (visible_rect).gobj()); 
-}
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void TreeView::widget_to_tree_coords(int wx, int wy, int& tx, int& ty)
 {
-gtk_tree_view_widget_to_tree_coords(gobj(), wx, wy, &tx, &ty); 
+  gtk_tree_view_widget_to_tree_coords(gobj(), wx, wy, &tx, &ty);
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
-void TreeView::widget_to_tree_coords(int wx, int wy, int& tx, int& ty) const
-{
-gtk_tree_view_widget_to_tree_coords(const_cast<GtkTreeView*>(gobj()), wx, wy, &tx, &ty); 
-}
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void TreeView::tree_to_widget_coords(int tx, int ty, int& wx, int& wy)
 {
-gtk_tree_view_tree_to_widget_coords(gobj(), tx, ty, &wx, &wy); 
-}
-
-#endif // GTKMM_DISABLE_DEPRECATED
-
-void TreeView::tree_to_widget_coords(int tx, int ty, int& wx, int& wy) const
-{
-gtk_tree_view_tree_to_widget_coords(const_cast<GtkTreeView*>(gobj()), tx, ty, &wx, &wy); 
+  gtk_tree_view_tree_to_widget_coords(gobj(), tx, ty, &wx, &wy);
 }
 
 void TreeView::unset_rows_drag_source()
 {
-gtk_tree_view_unset_rows_drag_source(gobj()); 
+  gtk_tree_view_unset_rows_drag_source(gobj());
 }
 
 void TreeView::unset_rows_drag_dest()
 {
-gtk_tree_view_unset_rows_drag_dest(gobj()); 
+  gtk_tree_view_unset_rows_drag_dest(gobj());
 }
 
 void TreeView::set_drag_dest_row(const TreeModel::Path& path, TreeViewDropPosition pos)
 {
-gtk_tree_view_set_drag_dest_row(gobj(), const_cast<GtkTreePath*>((path).gobj()), ((GtkTreeViewDropPosition)(pos))); 
+  gtk_tree_view_set_drag_dest_row(gobj(), const_cast<GtkTreePath*>((path).gobj()), ((GtkTreeViewDropPosition)(pos)));
 }
 
 Glib::RefPtr<Gdk::Pixmap> TreeView::create_row_drag_icon(const TreeModel::Path& path)
@@ -1519,7 +1409,7 @@ Glib::RefPtr<Gdk::Pixmap> TreeView::create_row_drag_icon(const TreeModel::Path&
 
 void TreeView::set_enable_search(bool enable_search)
 {
-gtk_tree_view_set_enable_search(gobj(), static_cast<int>(enable_search)); 
+  gtk_tree_view_set_enable_search(gobj(), static_cast<int>(enable_search));
 }
 
 bool TreeView::get_enable_search() const
@@ -1534,32 +1424,17 @@ int TreeView::get_search_column() const
 
 void TreeView::set_search_column(const TreeModelColumnBase& column)
 {
-gtk_tree_view_set_search_column(gobj(), (column).index()); 
+  gtk_tree_view_set_search_column(gobj(), (column).index());
 }
 
 void TreeView::set_search_column(int column)
 {
-gtk_tree_view_set_search_column(gobj(), column); 
-}
-
-Entry* TreeView::get_search_entry()
-{
-  return Glib::wrap(gtk_tree_view_get_search_entry(gobj()));
-}
-
-const Entry* TreeView::get_search_entry() const
-{
-  return const_cast<TreeView*>(this)->get_search_entry();
-}
-
-void TreeView::set_search_entry(Entry& entry)
-{
-gtk_tree_view_set_search_entry(gobj(), (entry).gobj()); 
+  gtk_tree_view_set_search_column(gobj(), column);
 }
 
 void TreeView::set_fixed_height_mode(bool enable)
 {
-gtk_tree_view_set_fixed_height_mode(gobj(), static_cast<int>(enable)); 
+  gtk_tree_view_set_fixed_height_mode(gobj(), static_cast<int>(enable));
 }
 
 bool TreeView::get_fixed_height_mode() const
@@ -1569,7 +1444,7 @@ bool TreeView::get_fixed_height_mode() const
 
 void TreeView::set_hover_selection(bool hover)
 {
-gtk_tree_view_set_hover_selection(gobj(), static_cast<int>(hover)); 
+  gtk_tree_view_set_hover_selection(gobj(), static_cast<int>(hover));
 }
 
 bool TreeView::get_hover_selection() const
@@ -1579,7 +1454,7 @@ bool TreeView::get_hover_selection() const
 
 void TreeView::set_hover_expand(bool expand)
 {
-gtk_tree_view_set_hover_expand(gobj(), static_cast<int>(expand)); 
+  gtk_tree_view_set_hover_expand(gobj(), static_cast<int>(expand));
 }
 
 bool TreeView::get_hover_expand() const
@@ -1587,339 +1462,179 @@ bool TreeView::get_hover_expand() const
   return gtk_tree_view_get_hover_expand(const_cast<GtkTreeView*>(gobj()));
 }
 
-void TreeView::set_rubber_banding(bool enable)
-{
-gtk_tree_view_set_rubber_banding(gobj(), static_cast<int>(enable)); 
-}
-
-bool TreeView::get_rubber_banding() const
-{
-  return gtk_tree_view_get_rubber_banding(const_cast<GtkTreeView*>(gobj()));
-}
-
-void TreeView::set_grid_lines(TreeViewGridLines grid_lines)
-{
-gtk_tree_view_set_grid_lines(gobj(), ((GtkTreeViewGridLines)(grid_lines))); 
-}
-
-TreeViewGridLines TreeView::get_grid_lines() const
-{
-  return ((TreeViewGridLines)(gtk_tree_view_get_grid_lines(const_cast<GtkTreeView*>(gobj()))));
-}
-
-void TreeView::set_enable_tree_lines(bool enable)
-{
-gtk_tree_view_set_enable_tree_lines(gobj(), static_cast<int>(enable)); 
-}
-
-bool TreeView::get_enable_tree_lines() const
-{
-  return gtk_tree_view_get_enable_tree_lines(const_cast<GtkTreeView*>(gobj()));
-}
-
 
 Glib::SignalProxy2< void,Adjustment*,Adjustment* > TreeView::signal_set_scroll_adjustments()
 {
   return Glib::SignalProxy2< void,Adjustment*,Adjustment* >(this, &TreeView_signal_set_scroll_adjustments_info);
 }
 
-
 Glib::SignalProxy2< void,const TreeModel::Path&,TreeViewColumn* > TreeView::signal_row_activated()
 {
   return Glib::SignalProxy2< void,const TreeModel::Path&,TreeViewColumn* >(this, &TreeView_signal_row_activated_info);
 }
 
-
 Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_test_expand_row()
 {
   return Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_test_expand_row_info);
 }
 
-
 Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_test_collapse_row()
 {
   return Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_test_collapse_row_info);
 }
 
-
 Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_row_expanded()
 {
   return Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_row_expanded_info);
 }
 
-
 Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > TreeView::signal_row_collapsed()
 {
   return Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& >(this, &TreeView_signal_row_collapsed_info);
 }
 
-
 Glib::SignalProxy0< void > TreeView::signal_cursor_changed()
 {
   return Glib::SignalProxy0< void >(this, &TreeView_signal_cursor_changed_info);
 }
 
-
 Glib::SignalProxy0< void > TreeView::signal_columns_changed()
 {
   return Glib::SignalProxy0< void >(this, &TreeView_signal_columns_changed_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<TreeModel> > TreeView::property_model() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > TreeView::property_model() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> >(this, "model");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Adjustment*> TreeView::property_hadjustment() 
 {
   return Glib::PropertyProxy<Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Adjustment*> TreeView::property_hadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Adjustment*> TreeView::property_vadjustment() 
 {
   return Glib::PropertyProxy<Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Adjustment*> TreeView::property_vadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_headers_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "headers-visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_headers_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "headers-visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_headers_clickable() 
 {
   return Glib::PropertyProxy<bool>(this, "headers-clickable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_headers_clickable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "headers-clickable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<TreeViewColumn*> TreeView::property_expander_column() 
 {
   return Glib::PropertyProxy<TreeViewColumn*>(this, "expander-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<TreeViewColumn*> TreeView::property_expander_column() const
 {
   return Glib::PropertyProxy_ReadOnly<TreeViewColumn*>(this, "expander-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_reorderable() 
 {
   return Glib::PropertyProxy<bool>(this, "reorderable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_reorderable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "reorderable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_rules_hint() 
 {
   return Glib::PropertyProxy<bool>(this, "rules-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_rules_hint() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "rules-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_enable_search() 
 {
   return Glib::PropertyProxy<bool>(this, "enable-search");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_enable_search() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-search");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TreeView::property_search_column() 
 {
   return Glib::PropertyProxy<int>(this, "search-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TreeView::property_search_column() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "search-column");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_fixed_height_mode() 
 {
   return Glib::PropertyProxy<bool>(this, "fixed-height-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_fixed_height_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "fixed-height-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_hover_selection() 
 {
   return Glib::PropertyProxy<bool>(this, "hover-selection");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_hover_selection() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "hover-selection");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeView::property_hover_expand() 
 {
   return Glib::PropertyProxy<bool>(this, "hover-expand");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeView::property_hover_expand() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "hover-expand");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> TreeView::property_show_expanders() 
-{
-  return Glib::PropertyProxy<bool>(this, "show-expanders");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> TreeView::property_show_expanders() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "show-expanders");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> TreeView::property_level_indentation() 
-{
-  return Glib::PropertyProxy<bool>(this, "level-indentation");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> TreeView::property_level_indentation() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "level-indentation");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> TreeView::property_rubber_banding() 
-{
-  return Glib::PropertyProxy<bool>(this, "rubber-banding");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> TreeView::property_rubber_banding() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "rubber-banding");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> TreeView::property_enable_grid_lines() 
-{
-  return Glib::PropertyProxy<bool>(this, "enable-grid-lines");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> TreeView::property_enable_grid_lines() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-grid-lines");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> TreeView::property_enable_tree_lines() 
-{
-  return Glib::PropertyProxy<bool>(this, "enable-tree-lines");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> TreeView::property_enable_tree_lines() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "enable-tree-lines");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TreeView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1929,6 +1644,7 @@ void Gtk::TreeView::on_set_scroll_adjustments(Adjustment* hadjustment, Adjustmen
   if(base && base->set_scroll_adjustments)
     (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
 }
+
 void Gtk::TreeView::on_row_activated(const TreeModel::Path& path, TreeViewColumn* column)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1938,6 +1654,7 @@ void Gtk::TreeView::on_row_activated(const TreeModel::Path& path, TreeViewColumn
   if(base && base->row_activated)
     (*base->row_activated)(gobj(),const_cast<GtkTreePath*>((path).gobj()),(GtkTreeViewColumn*)Glib::unwrap(column));
 }
+
 bool Gtk::TreeView::on_test_expand_row(const TreeModel::iterator& iter, const TreeModel::Path& path)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1950,6 +1667,7 @@ bool Gtk::TreeView::on_test_expand_row(const TreeModel::iterator& iter, const Tr
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::TreeView::on_test_collapse_row(const TreeModel::iterator& iter, const TreeModel::Path& path)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1962,6 +1680,7 @@ bool Gtk::TreeView::on_test_collapse_row(const TreeModel::iterator& iter, const
   typedef bool RType;
   return RType();
 }
+
 void Gtk::TreeView::on_row_expanded(const TreeModel::iterator& iter, const TreeModel::Path& path)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1971,6 +1690,7 @@ void Gtk::TreeView::on_row_expanded(const TreeModel::iterator& iter, const TreeM
   if(base && base->row_expanded)
     (*base->row_expanded)(gobj(),const_cast<GtkTreeIter*>((iter).gobj()),const_cast<GtkTreePath*>((path).gobj()));
 }
+
 void Gtk::TreeView::on_row_collapsed(const TreeModel::iterator& iter, const TreeModel::Path& path)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1980,6 +1700,7 @@ void Gtk::TreeView::on_row_collapsed(const TreeModel::iterator& iter, const Tree
   if(base && base->row_collapsed)
     (*base->row_collapsed)(gobj(),const_cast<GtkTreeIter*>((iter).gobj()),const_cast<GtkTreePath*>((path).gobj()));
 }
+
 void Gtk::TreeView::on_cursor_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1989,6 +1710,7 @@ void Gtk::TreeView::on_cursor_changed()
   if(base && base->cursor_changed)
     (*base->cursor_changed)(gobj());
 }
+
 void Gtk::TreeView::on_columns_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1998,10 +1720,6 @@ void Gtk::TreeView::on_columns_changed()
   if(base && base->columns_changed)
     (*base->columns_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview.h b/libs/gtkmm2/gtk/gtkmm/treeview.h
index 0be6852163..41a2bb9b9e 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeview.h
+++ b/libs/gtkmm2/gtk/gtkmm/treeview.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEVIEW_H
 #define _GTKMM_TREEVIEW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -34,7 +33,6 @@
 #include <gtkmm/treemodelcolumn.h>
 #include <gtkmm/cellrenderer.h>
 #include <gtkmm/targetentry.h>
-#include <gtkmm/entry.h>
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -83,38 +81,6 @@ public:
 namespace Gtk
 {
 
-/**
- * @ingroup gtkmmEnums
- */
-enum TreeViewGridLines
-{
-  TREE_VIEW_GRID_LINES_NONE,
-  TREE_VIEW_GRID_LINES_HORIZONTAL,
-  TREE_VIEW_GRID_LINES_VERTICAL,
-  TREE_VIEW_GRID_LINES_BOTH
-};
-
-} // namespace Gtk
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-namespace Glib
-{
-
-template <>
-class Value<Gtk::TreeViewGridLines> : public Glib::Value_Enum<Gtk::TreeViewGridLines>
-{
-public:
-  static GType value_type() G_GNUC_CONST;
-};
-
-} // namespace Glib
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gtk
-{
-
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
@@ -135,11 +101,11 @@ namespace TreeView_Private
   void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer, const Gtk::TreeModelColumn<ColumnType>& model_column);
 
   template<class ColumnType> inline
-  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*);
 
   template <class ColumnType> inline
-  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model); 
-
+  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*); 
+  
   template <class ColumnType> inline
   void _auto_cell_data_func(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterator& iter, int model_column, const Glib::ustring& format);
 }
@@ -210,16 +176,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment);
   virtual void on_row_activated(const TreeModel::Path& path, TreeViewColumn* column);
   virtual bool on_test_expand_row(const TreeModel::iterator& iter, const TreeModel::Path& path);
@@ -228,7 +189,6 @@ protected:
   virtual void on_row_collapsed(const TreeModel::iterator& iter, const TreeModel::Path& path);
   virtual void on_cursor_changed();
   virtual void on_columns_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -252,13 +212,13 @@ public:
   explicit TreeView(const Glib::RefPtr<TreeModel>& model);
 
   
-  /** Returns the model the Gtk::TreeView is based on.  Returns <tt>0</tt> if the
+  /** Returns the model the the Gtk::TreeView is based on.  Returns <tt>0</tt> if the
    * model is unset.
    * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
    */
   Glib::RefPtr<TreeModel> get_model();
   
-  /** Returns the model the Gtk::TreeView is based on.  Returns <tt>0</tt> if the
+  /** Returns the model the the Gtk::TreeView is based on.  Returns <tt>0</tt> if the
    * model is unset.
    * @return A Gtk::TreeModel, or <tt>0</tt> if none is currently being used.
    */
@@ -271,11 +231,6 @@ public:
    */
   void set_model(const Glib::RefPtr<TreeModel>& model);
   
-  /** Remove the model from the TreeView.
-   */
-  void unset_model();
-  
-  
   /** Gets the Gtk::TreeSelection associated with @a tree_view .
    * @return A Gtk::TreeSelection object.
    */
@@ -337,7 +292,7 @@ public:
    */
   bool get_headers_visible() const;
   
-  /** Sets the visibility state of the headers.
+  /** Sets the the visibility state of the headers.
    * @param headers_visible <tt>true</tt> if the headers are visible.
    */
   void set_headers_visible(bool headers_visible);
@@ -347,8 +302,6 @@ public:
    */
   void columns_autosize();
   
-  bool get_headers_clickable() const;
-  
   /** Allow the column title buttons to be clicked.
    * @param setting <tt>true</tt> if the columns are clickable.
    */
@@ -749,7 +702,7 @@ public:
   /** Expands the row at @a path . This will also expand all parent rows of
    *  @a path  as necessary.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param path Path to a row.
    */
   void expand_to_path(const TreeModel::Path& path);
@@ -832,7 +785,7 @@ public:
    * widget.  Please note that editing can only happen when the widget is
    * realized.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param path A Gtk::TreePath.
    * @param focus_column A Gtk::TreeViewColumn, or <tt>0</tt>.
    * @param focus_cell A Gtk::CellRenderer, or <tt>0</tt>.
@@ -873,17 +826,9 @@ public:
    */
   Glib::RefPtr<const Gdk::Window> get_bin_window() const;
 
-  #ifndef GTKMM_DISABLE_DEPRECATED
-
-  /** @deprecated Use the const version.
-   */
-  bool get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y);
-  #endif // GTKMM_DISABLE_DEPRECATED
-
-
   /** Finds the path at the point (x, y), relative to widget
    * coordinates. It is primarily for things like popup menus.
-   *
+   *  
    * @param x The x position to be identified
    * @param y The y position to be identified
    * @param path A reference to a TreeModel::Path to be filled in
@@ -894,11 +839,8 @@ public:
    *   can be placed
    * @return true if a row exists at that coordinate.
    */
-  bool get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y) const;
-
+  bool get_path_at_pos(int x, int y, TreeModel::Path& path, TreeViewColumn*& column, int& cell_x, int& cell_y);
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
   /** Fills the bounding rectangle in tree window coordinates for the cell at the
    * row specified by @a path  and the column specified by @a column .  If @a path  points to a path not currently displayed, the @a y  and @a height  fields
    * of the rectangle will be filled with 0.  The sum of all cell rects does not cover the
@@ -906,138 +848,55 @@ public:
    * returned rectangle is equivalent to the @a cell_area  passed to
    * Gtk::CellRenderer::render().  This function is only valid if #tree_view is
    * realized.
-   * @deprecated Use the const version
    * @param path A Gtk::TreePath for the row.
    * @param column A Gtk::TreeViewColumn for the column.
    * @param rect Rectangle to fill with cell rect.
    */
-  void get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
+  void get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle&  rect);
 //We ignore the fact that one of the arguments can be 0 - it does not seem useful.
 
   
   /** Fills the bounding rectangle in tree window coordinates for the cell at the
-   * row specified by @a path  and the column specified by @a column .  If @a path  points to a path not currently displayed, the @a y  and @a height  fields
-   * of the rectangle will be filled with 0.  The sum of all cell rects does not cover the
-   * entire tree; there are extra pixels in between rows, for example. The
-   * returned rectangle is equivalent to the @a cell_area  passed to
-   * Gtk::CellRenderer::render().  This function is only valid if #tree_view is
-   * realized.
-   * @param path A Gtk::TreePath for the row.
-   * @param column A Gtk::TreeViewColumn for the column.
-   * @param rect Rectangle to fill with cell rect.
-   */
-  void get_cell_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect) const;
-
-   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
-  /** Fills the bounding rectangle in tree window coordinates for the cell at the
    * row specified by @a path  and the column specified by @a column .  The returned rectangle is equivalent to the
    *  @a background_area  passed to Gtk::CellRenderer::render().  These background
    * areas tile to cover the entire tree window (except for the area used for
    * header buttons). Contrast with the @a cell_area , returned by
    * get_cell_area(), which returns only the cell itself, excluding
    * surrounding borders and the tree expander area.
-   * @deprecated Use the const version.
    * @param path A Gtk::TreePath for the row.
    * @param column A Gtk::TreeViewColumn for the column.
    * @param rect Rectangle to fill with cell background rect.
    */
   void get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-  /** Fills the bounding rectangle in tree window coordinates for the cell at the
-   * row specified by @a path  and the column specified by @a column .  The returned rectangle is equivalent to the
-   *  @a background_area  passed to Gtk::CellRenderer::render().  These background
-   * areas tile to cover the entire tree window (except for the area used for
-   * header buttons). Contrast with the @a cell_area , returned by
-   * get_cell_area(), which returns only the cell itself, excluding
-   * surrounding borders and the tree expander area.
-   * @param path A Gtk::TreePath for the row.
-   * @param column A Gtk::TreeViewColumn for the column.
-   * @param rect Rectangle to fill with cell background rect.
-   */
-  void get_background_area(const TreeModel::Path& path, TreeViewColumn& column, Gdk::Rectangle& rect) const;
   //We ignore the fact that one of the arguments can be 0 - it does not seem useful.
 
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
   /** Fills @a visible_rect  with the currently-visible region of the
    * buffer, in tree coordinates. Convert to widget coordinates with
    * tree_to_widget_coords(). Tree coordinates start at
    * 0,0 for row 0 of the tree, and cover the entire scrollable area of
    * the tree.
-   * @deprecated Use the const version.
    * @param visible_rect Rectangle to fill.
    */
   void get_visible_rect(Gdk::Rectangle&  visible_rect);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-  /** Fills @a visible_rect  with the currently-visible region of the
-   * buffer, in tree coordinates. Convert to widget coordinates with
-   * tree_to_widget_coords(). Tree coordinates start at
-   * 0,0 for row 0 of the tree, and cover the entire scrollable area of
-   * the tree.
-   * @param visible_rect Rectangle to fill.
-   */
-  void get_visible_rect(Gdk::Rectangle&  visible_rect) const;
-
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
   /** Converts widget coordinates to coordinates for the
    * tree window (the full scrollable area of the tree).
-   * @deprecated Use the const version
    * @param wx Widget X coordinate.
    * @param wy Widget Y coordinate.
    * @param tx Return location for tree X coordinate.
    * @param ty Return location for tree Y coordinate.
    */
   void widget_to_tree_coords(int wx, int wy, int& tx, int& ty);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-  /** Converts widget coordinates to coordinates for the
-   * tree window (the full scrollable area of the tree).
-   * @param wx Widget X coordinate.
-   * @param wy Widget Y coordinate.
-   * @param tx Return location for tree X coordinate.
-   * @param ty Return location for tree Y coordinate.
-   */
-  void widget_to_tree_coords(int wx, int wy, int& tx, int& ty) const;
-
   
-#ifndef GTKMM_DISABLE_DEPRECATED
-
   /** Converts tree coordinates (coordinates in full scrollable area of the tree)
    * to widget coordinates.
-   * @deprecated Use the const version.
    * @param tx Tree X coordinate.
    * @param ty Tree Y coordinate.
    * @param wx Return location for widget X coordinate.
    * @param wy Return location for widget Y coordinate.
    */
   void tree_to_widget_coords(int tx, int ty, int& wx, int& wy);
-#endif // GTKMM_DISABLE_DEPRECATED
-
-
-  /** Converts tree coordinates (coordinates in full scrollable area of the tree)
-   * to widget coordinates.
-   * @param tx Tree X coordinate.
-   * @param ty Tree Y coordinate.
-   * @param wx Return location for widget X coordinate.
-   * @param wy Return location for widget Y coordinate.
-   */
-  void tree_to_widget_coords(int tx, int ty, int& wx, int& wy) const;
-
-   bool get_visible_range(TreeModel::Path& start_path, TreeModel::Path& end_path) const;
-  
 
 /* Drag-and-Drop support */
   
@@ -1064,7 +923,7 @@ public:
                                 Gdk::DragAction actions = Gdk::ACTION_COPY | Gdk::ACTION_MOVE);                                                                                              
 
   
-  /** Turns the TreeView into a drop destination for automatic DND.
+  /** Turns the TreeViewinto a drop destination for automatic DND.
    *
    * @param targets The table of targets that the drag will support.
    * @param actions The bitmask of possible actions for a drag from this widget.
@@ -1124,8 +983,8 @@ public:
   bool get_dest_row_at_pos(int drag_x, int drag_y, TreeModel::Path& path, TreeViewDropPosition& pos) const;
 
   
-  /** Creates a Gdk::Pixmap representation of the row at @a path .  
-   * This image is used for a drag icon.
+  /** Creates a Gdk::Pixmap representation of the row at @a path .  This image is used
+   * for a drag icon.
    * @param path A Gtk::TreePath in @a tree_view .
    * @return A newly-allocated pixmap of the drag icon.
    */
@@ -1134,16 +993,12 @@ public:
 /* Interactive search */
   
   /** If @a enable_search  is set, then the user can type in text to search through
-   * the tree interactively (this is sometimes called "typeahead find").
-   * 
-   * Note that even if this is <tt>false</tt>, the user can still initiate a search 
-   * using the "start-interactive-search" key binding.
+   * the tree interactively.
    * @param enable_search <tt>true</tt>, if the user can search interactively.
    */
   void set_enable_search(bool enable_search = true);
   
-  /** Returns whether or not the tree allows to start interactive searching 
-   * by typing in text.
+  /** Returns whether or not the tree allows interactive searching.
    * @return Whether or not to let the user search interactively.
    */
   bool get_enable_search() const;
@@ -1154,26 +1009,16 @@ public:
   int get_search_column() const;
   
   /** Sets @a column  as the column where the interactive search code should
-   * search in. 
-   * 
-   * If the sort column is set, users can use the "start-interactive-search"
-   * key binding to bring up search popup. The enable-search property controls
-   * whether simply typing text will also start an interactive search.
-   * 
-   * Note that @a column  refers to a column of the model.
-   * @param column The column of the model to search in, or -1 to disable searching.
+   * search in.  Additionally, turns on interactive searching. Note that
+   *  @a column  refers to a column of the model.
+   * @param column The column of the model to search in.
    */
   void set_search_column(const TreeModelColumnBase& column);
   
   /** Sets @a column  as the column where the interactive search code should
-   * search in. 
-   * 
-   * If the sort column is set, users can use the "start-interactive-search"
-   * key binding to bring up search popup. The enable-search property controls
-   * whether simply typing text will also start an interactive search.
-   * 
-   * Note that @a column  refers to a column of the model.
-   * @param column The column of the model to search in, or -1 to disable searching.
+   * search in.  Additionally, turns on interactive searching. Note that
+   *  @a column  refers to a column of the model.
+   * @param column The column of the model to search in.
    */
   void set_search_column(int column);
 
@@ -1189,24 +1034,13 @@ public:
   void set_search_equal_func(const SlotSearchEqual& slot);
   
 
-  Entry* get_search_entry();
-  
-  const Entry* get_search_entry() const;
-  
-  void set_search_entry(Entry& entry);
-
-  ///void on_search_position(Gtk::Widget* search_dialog)
-  typedef sigc::slot<void, Gtk::Widget* /* search_dialog */> SlotSearchPosition;
-  void set_search_position_func(const SlotSearchPosition& slot);
-  
-
   /** Enables or disables the fixed height mode of @a tree_view . 
    * Fixed height mode speeds up Gtk::TreeView by assuming that all 
    * rows have the same height. 
    * Only enable this option if all rows are the same height and all
    * columns are of type Gtk::TREE_VIEW_COLUMN_FIXED.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param enable <tt>true</tt> to enable fixed height mode.
    */
   void set_fixed_height_mode(bool enable = true);
@@ -1214,7 +1048,7 @@ public:
   /** Returns whether fixed height mode is turned on for @a tree_view .
    * @return <tt>true</tt> if @a tree_view  is in fixed height mode
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_fixed_height_mode() const;
   
@@ -1223,7 +1057,7 @@ public:
    * Currently, this works only for the selection modes 
    * Gtk::SELECTION_SINGLE and Gtk::SELECTION_BROWSE.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param hover <tt>true</tt> to enable hover selection mode.
    */
   void set_hover_selection(bool hover = true);
@@ -1231,7 +1065,7 @@ public:
   /** Returns whether hover selection mode is turned on for @a tree_view .
    * @return <tt>true</tt> if @a tree_view  is in hover selection mode
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_hover_selection() const;
   
@@ -1239,7 +1073,7 @@ public:
    * Hover expansion makes rows expand or collaps if the pointer 
    * moves over them.
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param expand <tt>true</tt> to enable hover selection mode.
    */
   void set_hover_expand(bool expand = true);
@@ -1247,13 +1081,9 @@ public:
   /** Returns whether hover expansion mode is turned on for @a tree_view .
    * @return <tt>true</tt> if @a tree_view  is in hover expansion mode
    * 
-   * @newin2p6.
+   * Since: 2.6.
    */
   bool get_hover_expand() const;
-  
-  void set_rubber_banding(bool enable = true);
-  
-  bool get_rubber_banding() const;
 
   /** For instance,
    * void on_row_separator(const Gtk::TreeModel& model, const Gtk::TreeModel::iterator& iter);
@@ -1263,94 +1093,41 @@ public:
   void set_row_separator_func(const SlotRowSeparator& slot);
   
 
-  void set_grid_lines(TreeViewGridLines grid_lines);
-  
-  TreeViewGridLines get_grid_lines() const;
-
-  
-  void set_enable_tree_lines(bool enable = true);
-  
-  bool get_enable_tree_lines() const;
-
-
-/**
-   * @par Prototype:
-   * <tt>void %set_scroll_adjustments(Adjustment* hadjustment, Adjustment* vadjustment)</tt>
-   */
-
   Glib::SignalProxy2< void,Adjustment*,Adjustment* > signal_set_scroll_adjustments();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_activated(const TreeModel::Path& path, TreeViewColumn* column)</tt>
-   */
-
   Glib::SignalProxy2< void,const TreeModel::Path&,TreeViewColumn* > signal_row_activated();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %test_expand_row(const TreeModel::iterator& iter, const TreeModel::Path& path)</tt>
-   */
-
   Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > signal_test_expand_row();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %test_collapse_row(const TreeModel::iterator& iter, const TreeModel::Path& path)</tt>
-   */
-
   Glib::SignalProxy2< bool,const TreeModel::iterator&,const TreeModel::Path& > signal_test_collapse_row();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_expanded(const TreeModel::iterator& iter, const TreeModel::Path& path)</tt>
-   */
-
   Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > signal_row_expanded();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %row_collapsed(const TreeModel::iterator& iter, const TreeModel::Path& path)</tt>
-   */
-
   Glib::SignalProxy2< void,const TreeModel::iterator&,const TreeModel::Path& > signal_row_collapsed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %cursor_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_cursor_changed();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %columns_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_columns_changed();
 
 
   //Don't wrap these. They are keybinding signals, and their API broke for GTK+ 2.2.
   
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The model for the tree view.
+  /** The model for the tree view.
    *
    * 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<TreeModel> > property_model() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The model for the tree view.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1358,19 +1135,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TreeModel> > property_model() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Horizontal Adjustment for the widget.
+  /** Horizontal Adjustment for the 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<Adjustment*> property_hadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Horizontal Adjustment for the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1378,19 +1151,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Adjustment*> property_hadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Vertical Adjustment for the widget.
+  /** Vertical Adjustment for the 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<Adjustment*> property_vadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Vertical Adjustment for the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1398,19 +1167,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Adjustment*> property_vadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Show the column header buttons.
+  /** Show the column header buttons.
    *
    * 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_headers_visible() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Show the column header buttons.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1418,19 +1183,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_headers_visible() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Column headers respond to click events.
+  /** Column headers respond to click events.
    *
    * 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_headers_clickable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Column headers respond to click events.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1438,19 +1199,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_headers_clickable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Set the column for the expander column.
+  /** Set the column for the expander column.
    *
    * 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<TreeViewColumn*> property_expander_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Set the column for the expander column.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1458,19 +1215,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<TreeViewColumn*> property_expander_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** View is reorderable.
+  /** View is reorderable.
    *
    * 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_reorderable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** View is reorderable.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1478,19 +1231,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_reorderable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Set a hint to the theme engine to draw rows in alternating colors.
+  /** Set a hint to the theme engine to draw rows in alternating colors.
    *
    * 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_rules_hint() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Set a hint to the theme engine to draw rows in alternating colors.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1498,19 +1247,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_rules_hint() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** View allows user to search through columns interactively.
+  /** View allows user to search through columns interactively.
    *
    * 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_enable_search() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** View allows user to search through columns interactively.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1518,19 +1263,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_enable_search() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Model column to search through when searching through code.
+  /** Model column to search through when searching through code.
    *
    * 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_search_column() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Model column to search through when searching through code.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1538,19 +1279,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_search_column() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Speeds up GtkTreeView by assuming that all rows have the same height.
+  /** Speeds up GtkTreeView by assuming that all rows have the same 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<bool> property_fixed_height_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Speeds up GtkTreeView by assuming that all rows have the same height.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1558,19 +1295,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_fixed_height_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the selection should follow the pointer.
+  /** Whether the selection should follow the pointer.
    *
    * 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_hover_selection() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the selection should follow the pointer.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1578,19 +1311,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_hover_selection() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether rows should be expanded/collapsed when the pointer moves over them.
+  /** Whether rows should be expanded/collapsed when the pointer moves over them.
    *
    * 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_hover_expand() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether rows should be expanded/collapsed when the pointer moves over them.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -1598,126 +1327,20 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_hover_expand() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** View has expanders.
-   *
-   * 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_show_expanders() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** View has expanders.
-   *
-   * 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_show_expanders() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Extra indentation for each level.
-   *
-   * 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_level_indentation() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Extra indentation for each level.
-   *
-   * 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_level_indentation() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to enable selection of multiple items by dragging the mouse pointer.
-   *
-   * 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_rubber_banding() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to enable selection of multiple items by dragging the mouse pointer.
-   *
-   * 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_rubber_banding() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether grid lines should be drawn in the tree view.
-   *
-   * 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_enable_grid_lines() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether grid lines should be drawn in the tree view.
-   *
-   * 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_enable_grid_lines() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether tree lines should be drawn in the tree view.
-   *
-   * 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_enable_tree_lines() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether tree lines should be drawn in the tree view.
-   *
-   * 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_enable_tree_lines() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
   /// Get the treeview's model, but actually get the child model if it's a TreeModelFilter.
   Glib::RefPtr<Gtk::TreeModel> _get_base_model();
- 
+  
 protected:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template<class ColumnType> friend
-  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+  void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*);
 
   template <class ColumnType> friend
-  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
-
-  void _auto_store_on_cellrenderer_toggle_edited_with_model(const Glib::ustring& path_string, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
-
-  // This is no longer used, but we must keep it to prevent linker errors with already-compiled applications,
-  // For instance, applications that were compiled with the older versions of the templates that did use this method.
-  // TODO: Remove this when we can break API.
+  void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView*);
+  
   void _auto_store_on_cellrenderer_toggle_edited(const Glib::ustring& path_string, int model_column);
 
   template<class ColumnType> friend
@@ -1793,7 +1416,7 @@ int TreeView::append_column_numeric_editable(const Glib::ustring& title, const T
 template <class ColumnType> inline
 int TreeView::append_column_editable(const Glib::ustring& title, const TreeModelColumn<ColumnType>& model_column)
 {
-  //Don't use this in a header, because it gives warnings when disabled: g_assert(model_column.type() != 0);
+  g_assert(model_column.type() != 0);
 
   // compilation will fail if there is no appropriate TreeViewColumn
   // constructor for this model column type.
@@ -1842,33 +1465,17 @@ namespace TreeView_Private
 
 //bool specialization:
 template<> inline
-void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer, const Gtk::TreeModelColumn<bool>& model_column)
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<bool>& model_column)
 {
   Gtk::CellRendererToggle* pCellToggle = dynamic_cast<Gtk::CellRendererToggle*>(pCellRenderer);
   if(pCellToggle)
   {
     //Set the appropriate property,
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellToggle->property_activatable() = true;
-    #else
-    pCellToggle->set_property("activatable", true);
-    #endif
-
-    //Connect to the appropriate signal, sending the model_column too
-
-    sigc::slot<void, const Glib::ustring&, int> slot_temp = 
-      sigc::bind<-1>(
-        sigc::mem_fun(*this_p, &Gtk::TreeView::_auto_store_on_cellrenderer_toggle_edited_with_model), 
-        this_p->_get_base_model()
-      );
-
+  
+    //Connect to the appropriate signal, sending the model_column too,
     pCellToggle->signal_toggled().connect(
-      sigc::bind<-1>( 
-        slot_temp,
-        model_column.index()
-      )
-    );
-
+      sigc::bind<-1>( sigc::mem_fun(*this_p, &Gtk::TreeView::_auto_store_on_cellrenderer_toggle_edited), model_column.index()) );
     //We use bind<1> instead of bind because some compilers need the extra hint.
   }
 }
@@ -1881,23 +1488,17 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
   if(pCellText)
   {
     //Set the appropriate property,
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellText->property_editable() = true;
-    #else
-    pCellText->set_property("editable", true);
-    #endif
 
     //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
-    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
     type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<int>;
 
     //Connect to the appropriate signal, sending the model_column too,
     //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
     pCellText->signal_edited().connect(
       sigc::bind<-1>(
-        sigc::bind<-1>( 
-          sigc::ptr_fun(fptr),
-          this_p->_get_base_model() ),
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
         model_column.index()
       )
     );
@@ -1913,23 +1514,17 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
   if(pCellText)
   {
     //Set the appropriate property,
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellText->property_editable() = true;
-    #else
-    pCellText->set_property("editable", true);
-    #endif
 
     //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
-    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
     type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<unsigned int>;
 
     //Connect to the appropriate signal, sending the model_column too,
     //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
     pCellText->signal_edited().connect(
       sigc::bind<-1>(
-        sigc::bind<-1>( 
-          sigc::ptr_fun(fptr),
-          this_p->_get_base_model() ),
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
         model_column.index()
       )
     );
@@ -1945,23 +1540,17 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
   if(pCellText)
   {
     //Set the appropriate property,
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellText->property_editable() = true;
-    #else
-    pCellText->set_property("editable", true);
-    #endif
-
+     
     //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
-    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
     type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<long>;
 
     //Connect to the appropriate signal, sending the model_column too,
     //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
     pCellText->signal_edited().connect(
       sigc::bind<-1>(
-        sigc::bind<-1>( 
-          sigc::ptr_fun(fptr),
-          this_p->_get_base_model() ),
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
         model_column.index()
       )
     );
@@ -1977,27 +1566,21 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
   if(pCellText)
   {
     //Set the appropriate property,
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellText->property_editable() = true;
-    #else
-    pCellText->set_property("editable", true);
-    #endif
-
+  
     //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
-    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
     type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<unsigned long>;
 
     //Connect to the appropriate signal, sending the model_column too,
     //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
     pCellText->signal_edited().connect(
       sigc::bind<-1>(
-        sigc::bind<-1>( 
-          sigc::ptr_fun(fptr),
-          this_p->_get_base_model() ),
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
         model_column.index()
       )
     );
- 
+    
   }
 }
 
@@ -2009,23 +1592,17 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
   if(pCellText)
   {
     //Set the appropriate property,
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellText->property_editable() = true;
-    #else
-    pCellText->set_property("editable", true);
-    #endif
 
     //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
-    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
     type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<float>;
 
     //Connect to the appropriate signal, sending the model_column too,
     //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
     pCellText->signal_edited().connect(
       sigc::bind<-1>(
-        sigc::bind<-1>( 
-          sigc::ptr_fun(fptr),
-          this_p->_get_base_model() ),
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
         model_column.index()
       )
     );
@@ -2040,23 +1617,17 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
   if(pCellText)
   {
     //Set the appropriate property,
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellText->property_editable() = true;
-    #else
-    pCellText->set_property("editable", true);
-    #endif
 
     //Some compilers don't like us to give the pointer to a template function directly to sigc::ptr_fun():
-    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model);
+    typedef void (*type_fptr)(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p);
     type_fptr fptr = _auto_store_on_cellrenderer_text_edited_numerical<double>;
 
     //Connect to the appropriate signal, sending the model_column too,
     //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
     pCellText->signal_edited().connect(
       sigc::bind<-1>(
-        sigc::bind<-1>( 
-          sigc::ptr_fun(fptr),
-          this_p->_get_base_model() ),
+        sigc::bind<-1>( sigc::ptr_fun(fptr), this_p),
         model_column.index()
       )
     );
@@ -2076,9 +1647,9 @@ namespace TreeView_Private
 #ifdef GTKMM_HAVE_SIGC_BIND
 
 template <class ColumnType> inline
-void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer, const Gtk::TreeModelColumn<ColumnType>& model_column)
+void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::CellRenderer* pCellRenderer,  const Gtk::TreeModelColumn<ColumnType>& model_column)
 {
-  //Don't use this in a header, because it gives warnings when disabled: g_assert(model_column.type() != 0);
+  g_assert(model_column.type() != 0);
 
   //The different CellRenderers have different "edited" signals,
   //and numerical values need to convert the text value to a number,
@@ -2090,22 +1661,18 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
   //and connect to the appropriate signal, sending the model_column too,
   if(pCellText)
   {
-    #ifdef GLIBMM_PROPERTIES_ENABLED
     pCellText->property_editable() = true;
-    #else
-    pCellText->set_property("editable", true);
-    #endif
-
+   
     //Some compilers (IRIX MipsPro) don't like us to give the pointer to a template function directly to sigc::ptr_fun():
-    typedef void (*type_func)(const Glib::ustring&, const Glib::ustring&, int, const Glib::RefPtr<Gtk::TreeModel>&);
+    typedef void (*type_func)(const Glib::ustring&, const Glib::ustring&, int, Gtk::TreeView*);
     type_func func = &(_auto_store_on_cellrenderer_text_edited_string<ColumnType>);
-    sigc::slot<void, const Glib::ustring&, const Glib::ustring&, int, const Glib::RefPtr<Gtk::TreeModel>&> theslot  =
+    sigc::slot<void, const Glib::ustring&, const Glib::ustring&, int, Gtk::TreeView*> theslot  =
       sigc::ptr_fun(func);
 
     //We use bind<-1> twice here, instead of using bind() once, because some compilers need the extra hint.
     pCellText->signal_edited().connect(
       sigc::bind<-1>(
-        sigc::bind<-1>( theslot, this_p->_get_base_model()),
+        sigc::bind<-1>( theslot, this_p),
         model_column.index()
       )
     );
@@ -2117,48 +1684,44 @@ void _connect_auto_store_editable_signal_handler(Gtk::TreeView* this_p, Gtk::Cel
 #endif //GTKMM_HAVE_SIGC_BIND
 
 template <class ColumnType> inline
-void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model)
+void _auto_store_on_cellrenderer_text_edited_string(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p)
 {
   Gtk::TreePath path(path_string);
 
   //Get the row from the path:
-  if(model)
+  Glib::RefPtr<TreeModel> refModel = this_p->_get_base_model();
+  Gtk::TreeModel::iterator iter = refModel->get_iter(path);
+  if(iter)
   {
-    Gtk::TreeModel::iterator iter = model->get_iter(path);
-    if(iter)
-    {
-        //Store the user's new text in the model:
-        Gtk::TreeRow row = *iter;
-        row.set_value(model_column, (ColumnType)new_text);
-    }
+      //Store the user's new text in the model:
+      Gtk::TreeRow row = *iter;
+      row.set_value(model_column, (ColumnType)new_text);
   }
 }
 
 template <class ColumnType> inline
-void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, const Glib::RefPtr<Gtk::TreeModel>& model)
+void _auto_store_on_cellrenderer_text_edited_numerical(const Glib::ustring& path_string, const Glib::ustring& new_text, int model_column, Gtk::TreeView* this_p)
 {
   //This is used on numerical model columns:
 
   Gtk::TreePath path(path_string);
 
   //Get the row from the path:
-  if(model)
-  {
-    Gtk::TreeModel::iterator iter = model->get_iter(path);
-    if(iter)
-    {
-      //std::istringstream astream(new_text); //Put it in a stream.
-      //ColumnType new_value = ColumnType();
-      //new_value << astream; //Get it out of the stream as the numerical type.
-
-      //Convert the text to a number, using the same logic used by GtkCellRendererText when it stores numbers.
-      char* pchEnd = 0;
-      ColumnType new_value = static_cast<ColumnType>( strtod(new_text.c_str(), &pchEnd) );
+  Glib::RefPtr<TreeModel> refModel = this_p->_get_base_model();
+  Gtk::TreeModel::iterator iter = refModel->get_iter(path);
+  if(iter)
+  { 
+    //std::istringstream astream(new_text); //Put it in a stream.
+    //ColumnType new_value = ColumnType();
+    //new_value << astream; //Get it out of the stream as the numerical type.
+    
+    //Convert the text to a number, using the same logic used by GtkCellRendererText when it stores numbers.
+    char* pchEnd = 0;
+    ColumnType new_value = static_cast<ColumnType>( strtod(new_text.c_str(), &pchEnd) );
 
-      //Store the user's new text in the model:
-      Gtk::TreeRow row = *iter;
-      row.set_value(model_column, (ColumnType)new_value);
-    }
+    //Store the user's new text in the model:
+    Gtk::TreeRow row = *iter;
+    row.set_value(model_column, (ColumnType)new_value);
   }
 }
 
@@ -2178,18 +1741,14 @@ void _auto_cell_data_func(Gtk::CellRenderer* cell, const Gtk::TreeModel::iterato
       Gtk::TreeModel::Row row = *iter;
       ColumnType value = ColumnType();
       row.get_value(model_column, value);
-
+      
       //Convert it to a string representation:
       char buff[20];
       int used = g_snprintf(buff, sizeof(buff), format.c_str(), value); //value must be a numeric type.
       if(used > 0)
       {
         //Show the text representation in the view:
-        #ifdef GLIBMM_PROPERTIES_ENABLED
         pTextRenderer->property_text() = buff;
-        #else
-        pTextRenderer->set_property("text", (void*)buff);
-        #endif
       }
     }
   }
@@ -2210,8 +1769,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::TreeView* wrap(GtkTreeView* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TREEVIEW_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview_private.cc b/libs/gtkmm2/gtk/gtkmm/treeview_private.cc
index 0367008ddc..a18fce35f8 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeview_private.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treeview_private.cc
@@ -27,42 +27,52 @@ namespace Gtk
 namespace TreeView_Private
 {
 
-void SignalProxy_CellData_gtk_callback(GtkTreeViewColumn*, GtkCellRenderer* cell,
+SignalProxy_CellData::SignalProxy_CellData(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_CellData::~SignalProxy_CellData()
+{}
+
+void SignalProxy_CellData::gtk_callback(GtkTreeViewColumn*, GtkCellRenderer* cell,
                                         GtkTreeModel* model, GtkTreeIter* iter, void* data)
 {
-  TreeViewColumn::SlotCellData* the_slot = static_cast<TreeViewColumn::SlotCellData*>(data);
+  SignalProxy_CellData *const self = static_cast<SignalProxy_CellData*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLE
     // use Slot::operator()
-    (*the_slot)(Glib::wrap(cell, false), TreeIter(model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    (self->slot_)(Glib::wrap(cell, false), TreeIter(model, iter));
   }
   catch(...)
   {
     Glib::exception_handlers_invoke();
   }
-  #endif //GLIBMM_EXCEPTIONS_ENABLE
 }
 
-void SignalProxy_CellData_gtk_callback_destroy(void* data)
+void SignalProxy_CellData::gtk_callback_destroy(void* data)
 {
-  delete static_cast<TreeViewColumn::SlotCellData*>(data);
+  delete static_cast<SignalProxy_CellData*>(data);
 }
 
 
-gboolean SignalProxy_RowSeparator_gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, void* data)
+
+SignalProxy_RowSeparator::SignalProxy_RowSeparator(const SlotType& slot)
+:
+  slot_ (slot)
+{}
+
+SignalProxy_RowSeparator::~SignalProxy_RowSeparator()
+{}
+
+gboolean SignalProxy_RowSeparator::gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, void* data)
 {
-  TreeView::SlotRowSeparator* the_slot = static_cast<TreeView::SlotRowSeparator*>(data);
+  SignalProxy_RowSeparator *const self = static_cast<SignalProxy_RowSeparator*>(data);
 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLE
-    return (*the_slot)(Glib::wrap(model, true), Gtk::TreeIter(model, iter));
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
+    return (self->slot_)(Glib::wrap(model, true), Gtk::TreeIter(model, iter));
   }
   catch(...)
   {
@@ -70,12 +80,11 @@ gboolean SignalProxy_RowSeparator_gtk_callback(GtkTreeModel* model, GtkTreeIter*
   }
 
   return 0; // arbitrary value
-  #endif //GLIBMM_EXCEPTIONS_ENABLE
 }
 
-void SignalProxy_RowSeparator_gtk_callback_destroy(void* data)
+void SignalProxy_RowSeparator::gtk_callback_destroy(void* data)
 {
-  delete static_cast<TreeView::SlotRowSeparator*>(data);
+  delete static_cast<SignalProxy_RowSeparator*>(data);
 }
 
 
diff --git a/libs/gtkmm2/gtk/gtkmm/treeview_private.h b/libs/gtkmm2/gtk/gtkmm/treeview_private.h
index 42656b5ba8..418abe3a69 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeview_private.h
+++ b/libs/gtkmm2/gtk/gtkmm/treeview_private.h
@@ -32,12 +32,40 @@ namespace Gtk
 namespace TreeView_Private
 {
 
-void SignalProxy_CellData_gtk_callback(GtkTreeViewColumn*, GtkCellRenderer* cell,
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_CellData
+{
+public:
+  typedef TreeViewColumn::SlotCellData SlotType;
+
+  SignalProxy_CellData(const SlotType& slot);
+  ~SignalProxy_CellData();
+
+  static void gtk_callback(GtkTreeViewColumn*, GtkCellRenderer* cell,
                            GtkTreeModel* model, GtkTreeIter* iter, void* data);
-void SignalProxy_CellData_gtk_callback_destroy(void* data);
+  static void gtk_callback_destroy(void* data);
+
+protected:
+  SlotType slot_;
+};
+
+//SignalProxy_RowSeparator:
+
+//This Signal Proxy allows the C++ coder to specify a sigc::slot instead of a static function.
+class SignalProxy_RowSeparator
+{
+public:
+  typedef TreeView::SlotRowSeparator SlotType;
+
+  SignalProxy_RowSeparator(const SlotType& slot);
+  ~SignalProxy_RowSeparator();
+
+  static gboolean gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, void* data);
+  static void gtk_callback_destroy(void* data);
 
-gboolean SignalProxy_RowSeparator_gtk_callback(GtkTreeModel* model, GtkTreeIter* iter, void* data);
-void SignalProxy_RowSeparator_gtk_callback_destroy(void* data);
+protected:
+  SlotType slot_;
+};
 
 
 } /* namespace TreeView_Private */
diff --git a/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.cc b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.cc
index 97d84d629d..9a726fd39b 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.cc
+++ b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/treeviewcolumn.h>
 #include <gtkmm/private/treeviewcolumn_p.h>
 
@@ -54,42 +53,29 @@ TreeViewColumn::TreeViewColumn(const Glib::ustring& title, Gtk::CellRenderer& ce
   pack_start(cell, true);
 }
 
-void TreeViewColumn::add_attribute(Gtk::CellRenderer& cell, const Glib::ustring& property_name,
-                                   const TreeModelColumnBase& column)
-{
-  gtk_tree_view_column_add_attribute(gobj(),
-      (GtkCellRenderer*) cell.gobj(), property_name.c_str(), column.index());
-}
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 void TreeViewColumn::add_attribute(const Glib::PropertyProxy_Base& property,
                                    const TreeModelColumnBase& column)
 {
   gtk_tree_view_column_add_attribute(gobj(),
       (GtkCellRenderer*) property.get_object()->gobj(), property.get_name(), column.index());
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 void TreeViewColumn::set_renderer(Gtk::CellRenderer& renderer, const TreeModelColumnBase& column)
 {
-#ifdef GLIBMM_PROPERTIES_ENABLED
   add_attribute(renderer._property_renderable(), column);
-#else
-  add_attribute(renderer, renderer._property_renderable(), column);
-#endif
 }
 
 
 void TreeViewColumn::set_cell_data_func(CellRenderer& cell_renderer, const SlotCellData& slot)
 {
-  //Create a copy of the slot. A pointer to this will be passed through the callback's data parameter.
-  //It will be deleted when TreeView_Private::SignalProxy_CellData_gtk_callback_destroy() is called.
-  SlotCellData* slot_copy = new SlotCellData(slot);
+  //Create a signal proxy. A pointer to this will be passed through the callback's data parameter.
+  //It will be deleted when TreeView_Private::SignalProxy_CellData::gtk_callback_destroy() is called.
+  TreeView_Private::SignalProxy_CellData* pSignalProxy = new TreeView_Private::SignalProxy_CellData(slot);
 
   gtk_tree_view_column_set_cell_data_func(
       gobj(), cell_renderer.gobj(),
-      &TreeView_Private::SignalProxy_CellData_gtk_callback, slot_copy,
-      &TreeView_Private::SignalProxy_CellData_gtk_callback_destroy);
+      &TreeView_Private::SignalProxy_CellData::gtk_callback, pSignalProxy,
+      &TreeView_Private::SignalProxy_CellData::gtk_callback_destroy);
 }
 
 void TreeViewColumn::unset_cell_data_func(CellRenderer& cell_renderer)
@@ -113,19 +99,17 @@ const CellRenderer* TreeViewColumn::get_first_cell_renderer() const
   return const_cast<TreeViewColumn*>(this)->get_first_cell_renderer();
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+//deprecated:
 void TreeViewColumn::set_sort_column_id(const TreeModelColumnBase& sort_column)
 {
   set_sort_column(sort_column);
 }
 
+//deprecated:
 void TreeViewColumn::set_sort_column_id(int sort_column_id)
 {
   set_sort_column(sort_column_id);
-}
-#endif // GTKMM_DISABLE_DEPRECATED
-  
+}  
 
 } // namespace Gtk
 
@@ -133,15 +117,13 @@ void TreeViewColumn::set_sort_column_id(int sort_column_id)
 namespace
 {
 
-
-static const Glib::SignalProxyInfo TreeViewColumn_signal_clicked_info =
+const Glib::SignalProxyInfo TreeViewColumn_signal_clicked_info =
 {
   "clicked",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -192,18 +174,10 @@ void TreeViewColumn_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->clicked = &clicked_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void TreeViewColumn_Class::clicked_callback(GtkTreeViewColumn* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -216,19 +190,15 @@ void TreeViewColumn_Class::clicked_callback(GtkTreeViewColumn* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_clicked();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -241,7 +211,6 @@ void TreeViewColumn_Class::clicked_callback(GtkTreeViewColumn* self)
       (*base->clicked)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* TreeViewColumn_Class::wrap_new(GObject* o)
@@ -292,17 +261,17 @@ TreeViewColumn::TreeViewColumn()
 
 void TreeViewColumn::pack_start(CellRenderer& cell, bool expand)
 {
-gtk_tree_view_column_pack_start(gobj(), (cell).gobj(), static_cast<int>(expand)); 
+  gtk_tree_view_column_pack_start(gobj(), (cell).gobj(), static_cast<int>(expand));
 }
 
 void TreeViewColumn::pack_end(CellRenderer& cell, bool expand)
 {
-gtk_tree_view_column_pack_end(gobj(), (cell).gobj(), static_cast<int>(expand)); 
+  gtk_tree_view_column_pack_end(gobj(), (cell).gobj(), static_cast<int>(expand));
 }
 
 void TreeViewColumn::clear()
 {
-gtk_tree_view_column_clear(gobj()); 
+  gtk_tree_view_column_clear(gobj());
 }
 
 Glib::ListHandle<CellRenderer*> TreeViewColumn::get_cell_renderers()
@@ -317,17 +286,17 @@ Glib::ListHandle<const CellRenderer*> TreeViewColumn::get_cell_renderers() const
 
 void TreeViewColumn::add_attribute(CellRenderer& cell_renderer, const Glib::ustring& attribute, int column)
 {
-gtk_tree_view_column_add_attribute(gobj(), (cell_renderer).gobj(), attribute.c_str(), column); 
+  gtk_tree_view_column_add_attribute(gobj(), (cell_renderer).gobj(), attribute.c_str(), column);
 }
 
 void TreeViewColumn::clear_attributes(CellRenderer& cell_renderer)
 {
-gtk_tree_view_column_clear_attributes(gobj(), (cell_renderer).gobj()); 
+  gtk_tree_view_column_clear_attributes(gobj(), (cell_renderer).gobj());
 }
 
 void TreeViewColumn::set_spacing(int spacing)
 {
-gtk_tree_view_column_set_spacing(gobj(), spacing); 
+  gtk_tree_view_column_set_spacing(gobj(), spacing);
 }
 
 int TreeViewColumn::get_spacing() const
@@ -337,7 +306,7 @@ int TreeViewColumn::get_spacing() const
 
 void TreeViewColumn::set_visible(bool visible)
 {
-gtk_tree_view_column_set_visible(gobj(), static_cast<int>(visible)); 
+  gtk_tree_view_column_set_visible(gobj(), static_cast<int>(visible));
 }
 
 bool TreeViewColumn::get_visible() const
@@ -347,7 +316,7 @@ bool TreeViewColumn::get_visible() const
 
 void TreeViewColumn::set_resizable(bool resizable)
 {
-gtk_tree_view_column_set_resizable(gobj(), static_cast<int>(resizable)); 
+  gtk_tree_view_column_set_resizable(gobj(), static_cast<int>(resizable));
 }
 
 bool TreeViewColumn::get_resizable() const
@@ -357,7 +326,7 @@ bool TreeViewColumn::get_resizable() const
 
 void TreeViewColumn::set_sizing(TreeViewColumnSizing type)
 {
-gtk_tree_view_column_set_sizing(gobj(), ((GtkTreeViewColumnSizing)(type))); 
+  gtk_tree_view_column_set_sizing(gobj(), ((GtkTreeViewColumnSizing)(type)));
 }
 
 TreeViewColumnSizing TreeViewColumn::get_sizing()
@@ -377,12 +346,12 @@ int TreeViewColumn::get_fixed_width() const
 
 void TreeViewColumn::set_fixed_width(int fixed_width)
 {
-gtk_tree_view_column_set_fixed_width(gobj(), fixed_width); 
+  gtk_tree_view_column_set_fixed_width(gobj(), fixed_width);
 }
 
 void TreeViewColumn::set_min_width(int min_width)
 {
-gtk_tree_view_column_set_min_width(gobj(), min_width); 
+  gtk_tree_view_column_set_min_width(gobj(), min_width);
 }
 
 int TreeViewColumn::get_min_width() const
@@ -392,7 +361,7 @@ int TreeViewColumn::get_min_width() const
 
 void TreeViewColumn::set_max_width(int max_width)
 {
-gtk_tree_view_column_set_max_width(gobj(), max_width); 
+  gtk_tree_view_column_set_max_width(gobj(), max_width);
 }
 
 int TreeViewColumn::get_max_width() const
@@ -402,12 +371,12 @@ int TreeViewColumn::get_max_width() const
 
 void TreeViewColumn::clicked()
 {
-gtk_tree_view_column_clicked(gobj()); 
+  gtk_tree_view_column_clicked(gobj());
 }
 
 void TreeViewColumn::set_title(const Glib::ustring& title)
 {
-gtk_tree_view_column_set_title(gobj(), title.c_str()); 
+  gtk_tree_view_column_set_title(gobj(), title.c_str());
 }
 
 Glib::ustring TreeViewColumn::get_title() const
@@ -417,7 +386,7 @@ Glib::ustring TreeViewColumn::get_title() const
 
 void TreeViewColumn::set_expand(bool expand)
 {
-gtk_tree_view_column_set_expand(gobj(), static_cast<int>(expand)); 
+  gtk_tree_view_column_set_expand(gobj(), static_cast<int>(expand));
 }
 
 bool TreeViewColumn::get_expand() const
@@ -427,7 +396,7 @@ bool TreeViewColumn::get_expand() const
 
 void TreeViewColumn::set_clickable(bool clickable)
 {
-gtk_tree_view_column_set_clickable(gobj(), static_cast<int>(clickable)); 
+  gtk_tree_view_column_set_clickable(gobj(), static_cast<int>(clickable));
 }
 
 bool TreeViewColumn::get_clickable() const
@@ -437,7 +406,7 @@ bool TreeViewColumn::get_clickable() const
 
 void TreeViewColumn::set_widget(Gtk::Widget& widget)
 {
-gtk_tree_view_column_set_widget(gobj(), (widget).gobj()); 
+  gtk_tree_view_column_set_widget(gobj(), (widget).gobj());
 }
 
 Widget* TreeViewColumn::get_widget()
@@ -452,12 +421,12 @@ const Widget* TreeViewColumn::get_widget() const
 
 void TreeViewColumn::set_alignment(float xalign)
 {
-gtk_tree_view_column_set_alignment(gobj(), xalign); 
+  gtk_tree_view_column_set_alignment(gobj(), xalign);
 }
 
 void TreeViewColumn::set_alignment(AlignmentEnum xalign)
 {
-gtk_tree_view_column_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign)); 
+  gtk_tree_view_column_set_alignment(gobj(), _gtkmm_align_float_from_enum(xalign));
 }
 
 float TreeViewColumn::get_alignment() const
@@ -467,7 +436,7 @@ float TreeViewColumn::get_alignment() const
 
 void TreeViewColumn::set_reorderable(bool reorderable)
 {
-gtk_tree_view_column_set_reorderable(gobj(), static_cast<int>(reorderable)); 
+  gtk_tree_view_column_set_reorderable(gobj(), static_cast<int>(reorderable));
 }
 
 bool TreeViewColumn::get_reorderable() const
@@ -477,12 +446,12 @@ bool TreeViewColumn::get_reorderable() const
 
 void TreeViewColumn::set_sort_column(const TreeModelColumnBase& sort_column_id)
 {
-gtk_tree_view_column_set_sort_column_id(gobj(), (sort_column_id).index()); 
+  gtk_tree_view_column_set_sort_column_id(gobj(), (sort_column_id).index());
 }
 
 void TreeViewColumn::set_sort_column(int sort_column_id)
 {
-gtk_tree_view_column_set_sort_column_id(gobj(), sort_column_id); 
+  gtk_tree_view_column_set_sort_column_id(gobj(), sort_column_id);
 }
 
 int TreeViewColumn::get_sort_column_id() const
@@ -492,7 +461,7 @@ int TreeViewColumn::get_sort_column_id() const
 
 void TreeViewColumn::set_sort_indicator(bool setting)
 {
-gtk_tree_view_column_set_sort_indicator(gobj(), static_cast<int>(setting)); 
+  gtk_tree_view_column_set_sort_indicator(gobj(), static_cast<int>(setting));
 }
 
 bool TreeViewColumn::get_sort_indicator() const
@@ -502,7 +471,7 @@ bool TreeViewColumn::get_sort_indicator() const
 
 void TreeViewColumn::set_sort_order(SortType order)
 {
-gtk_tree_view_column_set_sort_order(gobj(), ((GtkSortType)(order))); 
+  gtk_tree_view_column_set_sort_order(gobj(), ((GtkSortType)(order)));
 }
 
 SortType TreeViewColumn::get_sort_order() const
@@ -512,12 +481,12 @@ SortType TreeViewColumn::get_sort_order() const
 
 void TreeViewColumn::cell_set_cell_data(const Glib::RefPtr<TreeModel>& tree_model, const TreeModel::iterator& iter, bool is_expander, bool is_expanded)
 {
-gtk_tree_view_column_cell_set_cell_data(gobj(), Glib::unwrap(tree_model), const_cast<GtkTreeIter*>((iter).gobj()), static_cast<int>(is_expander), static_cast<int>(is_expanded)); 
+  gtk_tree_view_column_cell_set_cell_data(gobj(), Glib::unwrap(tree_model), const_cast<GtkTreeIter*>((iter).gobj()), static_cast<int>(is_expander), static_cast<int>(is_expanded));
 }
 
 void TreeViewColumn::cell_get_size(Gdk::Rectangle& cell_area, int& x_offset, int& y_offset, int& width, int& height) const
 {
-gtk_tree_view_column_cell_get_size(const_cast<GtkTreeViewColumn*>(gobj()), (cell_area).gobj(), &x_offset, &y_offset, &width, &height); 
+  gtk_tree_view_column_cell_get_size(const_cast<GtkTreeViewColumn*>(gobj()), (cell_area).gobj(), &x_offset, &y_offset, &width, &height);
 }
 
 bool TreeViewColumn::cell_is_visible() const
@@ -527,7 +496,7 @@ bool TreeViewColumn::cell_is_visible() const
 
 void TreeViewColumn::focus_cell(CellRenderer& cell)
 {
-gtk_tree_view_column_focus_cell(gobj(), (cell).gobj()); 
+  gtk_tree_view_column_focus_cell(gobj(), (cell).gobj());
 }
 
 bool TreeViewColumn::get_cell_position(const CellRenderer& cell_renderer, int& start_pos, int& width) const
@@ -535,11 +504,6 @@ bool TreeViewColumn::get_cell_position(const CellRenderer& cell_renderer, int& s
   return gtk_tree_view_column_cell_get_position(const_cast<GtkTreeViewColumn*>(gobj()), const_cast<GtkCellRenderer*>((cell_renderer).gobj()), &start_pos, &width);
 }
 
-void TreeViewColumn::queue_resize()
-{
-gtk_tree_view_column_queue_resize(gobj()); 
-}
-
 
 Glib::SignalProxy0< void > TreeViewColumn::signal_clicked()
 {
@@ -547,197 +511,142 @@ Glib::SignalProxy0< void > TreeViewColumn::signal_clicked()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeViewColumn::property_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<TreeViewColumnSizing> TreeViewColumn::property_sizing() 
 {
   return Glib::PropertyProxy<TreeViewColumnSizing>(this, "sizing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<TreeViewColumnSizing> TreeViewColumn::property_sizing() const
 {
   return Glib::PropertyProxy_ReadOnly<TreeViewColumnSizing>(this, "sizing");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TreeViewColumn::property_fixed_width() 
 {
   return Glib::PropertyProxy<int>(this, "fixed-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_fixed_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "fixed-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TreeViewColumn::property_min_width() 
 {
   return Glib::PropertyProxy<int>(this, "min-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_min_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "min-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> TreeViewColumn::property_max_width() 
 {
   return Glib::PropertyProxy<int>(this, "max-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> TreeViewColumn::property_max_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "max-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> TreeViewColumn::property_title() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> TreeViewColumn::property_title() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeViewColumn::property_expand() 
 {
   return Glib::PropertyProxy<bool>(this, "expand");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_expand() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "expand");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeViewColumn::property_clickable() 
 {
   return Glib::PropertyProxy<bool>(this, "clickable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_clickable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "clickable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Widget*> TreeViewColumn::property_widget() 
 {
   return Glib::PropertyProxy<Widget*>(this, "widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Widget*> TreeViewColumn::property_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Widget*>(this, "widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<float> TreeViewColumn::property_alignment() 
 {
   return Glib::PropertyProxy<float>(this, "alignment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<float> TreeViewColumn::property_alignment() const
 {
   return Glib::PropertyProxy_ReadOnly<float>(this, "alignment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeViewColumn::property_reorderable() 
 {
   return Glib::PropertyProxy<bool>(this, "reorderable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_reorderable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "reorderable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> TreeViewColumn::property_sort_indicator() 
 {
   return Glib::PropertyProxy<bool>(this, "sort-indicator");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> TreeViewColumn::property_sort_indicator() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "sort-indicator");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<SortType> TreeViewColumn::property_sort_order() 
 {
   return Glib::PropertyProxy<SortType>(this, "sort-order");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<SortType> TreeViewColumn::property_sort_order() const
 {
   return Glib::PropertyProxy_ReadOnly<SortType>(this, "sort-order");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::TreeViewColumn::on_clicked()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -747,10 +656,6 @@ void Gtk::TreeViewColumn::on_clicked()
   if(base && base->clicked)
     (*base->clicked)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.h b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.h
index e6ba175e46..e4b7ef9296 100644
--- a/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.h
+++ b/libs/gtkmm2/gtk/gtkmm/treeviewcolumn.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_TREEVIEWCOLUMN_H
 #define _GTKMM_TREEVIEWCOLUMN_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -80,19 +79,13 @@ namespace Gtk
 {
 
 
-// We use GTKMM_API here because gcc needs the extra help on win32 , even 
-// when using --export-all and auto-import. 
-// See http://bugzilla.gnome.org/show_bug.cgi?id=309030.
-
-//TODO: This should derive+implement from CellLayout when we can break ABI.
-
 /** Typedefed as Gtk::TreeView::Column.
  * This is a visible column in a Gtk::TreeView widget. It determines the geometry, type.
  *
  * @ingroup TreeView
 */
 
-class GTKMM_API TreeViewColumn : public Gtk::Object
+class TreeViewColumn : public Gtk::Object
 {
   public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -135,18 +128,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_clicked();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -251,11 +238,7 @@ public:
    */
   void add_attribute(CellRenderer& cell_renderer, const Glib::ustring& attribute, int column);
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
   void add_attribute(const Glib::PropertyProxy_Base& property, const TreeModelColumnBase& column);
-#endif
-
-  void add_attribute(Gtk::CellRenderer& cell, const Glib::ustring& property_name, const TreeModelColumnBase& column);
   
 
   /** Associate a view CellRenderer with a model column, so that the CellRenderer renders the data in the model column.
@@ -412,15 +395,14 @@ public:
    * option set, then the last column gets all extra space.  By default, every
    * column is created with this <tt>false</tt>.
    * 
-   * @newin2p4
-   * @param expand <tt>true</tt> if the column should take available extra space, <tt>false</tt> if not.
+   * Since: 2.4
    */
   void set_expand(bool expand = true);
   
   /** Return <tt>true</tt> if the column expands to take any available space.
    * @return <tt>true</tt>, if the column expands
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_expand() const;
 
@@ -501,7 +483,6 @@ public:
   void set_sort_column(int sort_column_id);
 
   #ifndef GTKMM_DISABLE_DEPRECATED
-
   /** @deprecated Use set_sort_column() instead.
    */
   void set_sort_column_id(const TreeModelColumnBase& sort_column_id);
@@ -509,9 +490,9 @@ public:
   /** @deprecated Use set_sort_column() instead.
    */
   void set_sort_column_id(int sort_column_id);
-  #endif // GTKMM_DISABLE_DEPRECATED
-
-
+  #endif //GTKMM_DISABLE_DEPRECATED
+  
+  
   /** Gets the logical @a sort_column_id  that the model sorts on when this
    * column is selected for sorting.
    * See set_sort_column_id().
@@ -585,7 +566,7 @@ public:
   /** Sets the current keyboard focus to be at @a cell , if the column contains
    * 2 or more editable and activatable cells.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param cell A Gtk::CellRenderer.
    */
   void focus_cell(CellRenderer& cell);
@@ -601,34 +582,19 @@ public:
    * @return <tt>true</tt> if @a cell  belongs to @a tree_column .
    */
   bool get_cell_position(const CellRenderer& cell_renderer, int& start_pos, int& width) const;
-  
-  /** Flags the column, and the cell renderers added to this column, to have
-   * their sizes renegotiated.
-   * 
-   * @newin2p8
-   */
-  void queue_resize();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %clicked()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_clicked();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to display the column.
+  /** Whether to display the column.
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to display the column.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -636,30 +602,24 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Current width of the column.
+  /** Current width of the column.
    *
    * 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_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Resize mode of the column.
+  /** Resize mode of the column.
    *
    * 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<TreeViewColumnSizing> property_sizing() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Resize mode of the column.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -667,19 +627,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<TreeViewColumnSizing> property_sizing() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Current fixed width of the column.
+  /** Current fixed width of the column.
    *
    * 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_fixed_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Current fixed width of the column.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -687,19 +643,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_fixed_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Minimum allowed width of the column.
+  /** Minimum allowed width of the column.
    *
    * 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_min_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Minimum allowed width of the column.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -707,19 +659,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_min_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Maximum allowed width of the column.
+  /** Maximum allowed width of the column.
    *
    * 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_max_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Maximum allowed width of the column.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -727,19 +675,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_max_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Title to appear in column header.
+  /** Title to appear in column header.
    *
    * 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_title() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Title to appear in column header.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -747,19 +691,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Column gets share of extra width allocated to the widget.
+  /** Column gets share of extra width allocated to the 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<bool> property_expand() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Column gets share of extra width allocated to the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -767,19 +707,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_expand() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the header can be clicked.
+  /** Whether the header can be clicked.
    *
    * 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_clickable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the header can be clicked.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -787,19 +723,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_clickable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Widget to put in column header button instead of column title.
+  /** Widget to put in column header button instead of column title.
    *
    * 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<Widget*> property_widget() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Widget to put in column header button instead of column title.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -807,19 +739,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Widget*> property_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** X Alignment of the column header text or widget.
+  /** X Alignment of the column header text or 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<float> property_alignment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** X Alignment of the column header text or widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -827,19 +755,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<float> property_alignment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the column can be reordered around the headers.
+  /** Whether the column can be reordered around the headers.
    *
    * 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_reorderable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the column can be reordered around the headers.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -847,19 +771,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_reorderable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to show a sort indicator.
+  /** Whether to show a sort indicator.
    *
    * 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_sort_indicator() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether to show a sort indicator.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -867,19 +787,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_sort_indicator() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Sort direction the sort indicator should indicate.
+  /** Sort direction the sort indicator should indicate.
    *
    * 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<SortType> property_sort_order() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Sort direction the sort indicator should indicate.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -887,7 +803,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<SortType> property_sort_order() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -901,7 +816,7 @@ private:
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
-template<class T_ModelColumnType> inline
+template<class T_ModelColumnType>
 void TreeViewColumn::pack_start(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
 {
   //Generate appropriate Renderer for the column:
@@ -912,7 +827,7 @@ void TreeViewColumn::pack_start(const TreeModelColumn<T_ModelColumnType>& column
   set_renderer(*pCellRenderer, column);
 }
 
-template<class T_ModelColumnType> inline
+template<class T_ModelColumnType>
 void TreeViewColumn::pack_end(const TreeModelColumn<T_ModelColumnType>& column, bool expand)
 {
   //Generate appropriate Renderer for the column:
@@ -924,7 +839,7 @@ void TreeViewColumn::pack_end(const TreeModelColumn<T_ModelColumnType>& column,
 }
 
 
-template <class T_ModelColumnType> inline
+template <class T_ModelColumnType>
 TreeViewColumn::TreeViewColumn(const Glib::ustring& title,
                                const TreeModelColumn<T_ModelColumnType>& column)
 :
@@ -948,8 +863,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::TreeViewColumn* wrap(GtkTreeViewColumn* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_TREEVIEWCOLUMN_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/uimanager.cc b/libs/gtkmm2/gtk/gtkmm/uimanager.cc
index f38daaa209..89088a1474 100644
--- a/libs/gtkmm2/gtk/gtkmm/uimanager.cc
+++ b/libs/gtkmm2/gtk/gtkmm/uimanager.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/uimanager.h>
 #include <gtkmm/private/uimanager_p.h>
 
@@ -32,23 +31,11 @@ namespace Gtk
 
 typedef UIManager::ui_merge_id ui_merge_id; //Help gmmproc so that it does not need to add the full type name for the return type.
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 UIManager::ui_merge_id UIManager::add_ui_from_string(const Glib::ustring& buffer)
-#else
-UIManager::ui_merge_id UIManager::add_ui_from_string(const Glib::ustring& buffer, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  guint retvalue = gtk_ui_manager_add_ui_from_string(gobj(), buffer.c_str(), buffer.size(), &(gerror));
-
-  if (gerror)
-  { 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  ::Glib::Error::throw_exception(gerror);
-#else
-  error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-  }
+{
+  GError *error = 0;
+  guint retvalue = gtk_ui_manager_add_ui_from_string(gobj(), buffer.c_str(), buffer.size(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
 }
 
@@ -64,8 +51,7 @@ void UIManager::add_ui_separator(ui_merge_id merge_id, const Glib::ustring& path
 namespace
 {
 
-
-static void UIManager_signal_add_widget_callback(GtkUIManager* self, GtkWidget* p0,void* data)
+void UIManager_signal_add_widget_callback(GtkUIManager* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -73,24 +59,20 @@ static void UIManager_signal_add_widget_callback(GtkUIManager* self, GtkWidget*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo UIManager_signal_add_widget_info =
+const Glib::SignalProxyInfo UIManager_signal_add_widget_info =
 {
   "add_widget",
   (GCallback) &UIManager_signal_add_widget_callback,
@@ -98,7 +80,7 @@ static const Glib::SignalProxyInfo UIManager_signal_add_widget_info =
 };
 
 
-static const Glib::SignalProxyInfo UIManager_signal_actions_changed_info =
+const Glib::SignalProxyInfo UIManager_signal_actions_changed_info =
 {
   "actions_changed",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -106,7 +88,7 @@ static const Glib::SignalProxyInfo UIManager_signal_actions_changed_info =
 };
 
 
-static void UIManager_signal_connect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
+void UIManager_signal_connect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
@@ -114,25 +96,21 @@ static void UIManager_signal_connect_proxy_callback(GtkUIManager* self, GtkActio
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo UIManager_signal_connect_proxy_info =
+const Glib::SignalProxyInfo UIManager_signal_connect_proxy_info =
 {
   "connect_proxy",
   (GCallback) &UIManager_signal_connect_proxy_callback,
@@ -140,7 +118,7 @@ static const Glib::SignalProxyInfo UIManager_signal_connect_proxy_info =
 };
 
 
-static void UIManager_signal_disconnect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
+void UIManager_signal_disconnect_proxy_callback(GtkUIManager* self, GtkAction* p0,GtkWidget* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>&,Widget* > SlotType;
@@ -148,25 +126,21 @@ static void UIManager_signal_disconnect_proxy_callback(GtkUIManager* self, GtkAc
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo UIManager_signal_disconnect_proxy_info =
+const Glib::SignalProxyInfo UIManager_signal_disconnect_proxy_info =
 {
   "disconnect_proxy",
   (GCallback) &UIManager_signal_disconnect_proxy_callback,
@@ -174,7 +148,7 @@ static const Glib::SignalProxyInfo UIManager_signal_disconnect_proxy_info =
 };
 
 
-static void UIManager_signal_pre_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
+void UIManager_signal_pre_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
@@ -182,24 +156,20 @@ static void UIManager_signal_pre_activate_callback(GtkUIManager* self, GtkAction
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo UIManager_signal_pre_activate_info =
+const Glib::SignalProxyInfo UIManager_signal_pre_activate_info =
 {
   "pre_activate",
   (GCallback) &UIManager_signal_pre_activate_callback,
@@ -207,7 +177,7 @@ static const Glib::SignalProxyInfo UIManager_signal_pre_activate_info =
 };
 
 
-static void UIManager_signal_post_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
+void UIManager_signal_post_activate_callback(GtkUIManager* self, GtkAction* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Action>& > SlotType;
@@ -215,31 +185,26 @@ static void UIManager_signal_post_activate_callback(GtkUIManager* self, GtkActio
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo UIManager_signal_post_activate_info =
+const Glib::SignalProxyInfo UIManager_signal_post_activate_info =
 {
   "post_activate",
   (GCallback) &UIManager_signal_post_activate_callback,
   (GCallback) &UIManager_signal_post_activate_callback
 };
 
-
 } // anonymous namespace
 
 // static
@@ -292,19 +257,11 @@ void UIManager_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->add_widget = &add_widget_callback;
   klass->actions_changed = &actions_changed_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void UIManager_Class::add_widget_callback(GtkUIManager* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -317,20 +274,16 @@ void UIManager_Class::add_widget_callback(GtkUIManager* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_add_widget(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -343,6 +296,7 @@ void UIManager_Class::add_widget_callback(GtkUIManager* self, GtkWidget* p0)
       (*base->add_widget)(self, p0);
   }
 }
+
 void UIManager_Class::actions_changed_callback(GtkUIManager* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -355,19 +309,15 @@ void UIManager_Class::actions_changed_callback(GtkUIManager* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_actions_changed();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -380,7 +330,6 @@ void UIManager_Class::actions_changed_callback(GtkUIManager* self)
       (*base->actions_changed)(self);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* UIManager_Class::wrap_new(GObject* object)
@@ -437,7 +386,7 @@ Glib::RefPtr<UIManager> UIManager::create()
 }
 void UIManager::set_add_tearoffs(bool add_tearoffs)
 {
-gtk_ui_manager_set_add_tearoffs(gobj(), static_cast<int>(add_tearoffs)); 
+  gtk_ui_manager_set_add_tearoffs(gobj(), static_cast<int>(add_tearoffs));
 }
 
 bool UIManager::get_add_tearoffs() const
@@ -447,17 +396,17 @@ bool UIManager::get_add_tearoffs() const
 
 void UIManager::insert_action_group(const Glib::RefPtr<ActionGroup>& action_group, int pos)
 {
-gtk_ui_manager_insert_action_group(gobj(), Glib::unwrap(action_group), pos); 
+  gtk_ui_manager_insert_action_group(gobj(), Glib::unwrap(action_group), pos);
 }
 
 void UIManager::remove_action_group(const Glib::RefPtr<ActionGroup>& action_group)
 {
-gtk_ui_manager_remove_action_group(gobj(), Glib::unwrap(action_group)); 
+  gtk_ui_manager_remove_action_group(gobj(), Glib::unwrap(action_group));
 }
 
 Glib::ListHandle< Glib::RefPtr<ActionGroup> > UIManager::get_action_groups()
 {
-  return Glib::ListHandle< Glib::RefPtr<ActionGroup> >(gtk_ui_manager_get_action_groups(gobj()), Glib::OWNERSHIP_NONE);
+  return Glib::ListHandle< Glib::RefPtr<ActionGroup> >(gtk_ui_manager_get_action_groups(gobj()), Glib::OWNERSHIP_SHALLOW);
 }
 
 Glib::ListHandle< Glib::RefPtr<const ActionGroup> > UIManager::get_action_groups() const
@@ -469,15 +418,20 @@ Glib::RefPtr<AccelGroup> UIManager::get_accel_group()
 {
 
   Glib::RefPtr<AccelGroup> retvalue = Glib::wrap(gtk_ui_manager_get_accel_group(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const AccelGroup> UIManager::get_accel_group() const
 {
-  return const_cast<UIManager*>(this)->get_accel_group();
+
+  Glib::RefPtr<const AccelGroup> retvalue = Glib::wrap(gtk_ui_manager_get_accel_group(const_cast<GtkUIManager*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Widget* UIManager::get_widget(const Glib::ustring& path)
@@ -487,7 +441,7 @@ Widget* UIManager::get_widget(const Glib::ustring& path)
 
 const Widget* UIManager::get_widget(const Glib::ustring& path) const
 {
-  return const_cast<UIManager*>(this)->get_widget(path);
+  return Glib::wrap(gtk_ui_manager_get_widget(const_cast<GtkUIManager*>(gobj()), path.c_str()));
 }
 
 Glib::SListHandle<Widget*> UIManager::get_toplevels(UIManagerItemType types)
@@ -504,45 +458,38 @@ Glib::RefPtr<Action> UIManager::get_action(const Glib::ustring& path)
 {
 
   Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_ui_manager_get_action(gobj(), path.c_str()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Action> UIManager::get_action(const Glib::ustring& path) const
 {
-  return const_cast<UIManager*>(this)->get_action(path);
-}
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-ui_merge_id UIManager::add_ui_from_file(const Glib::ustring& filename)
-#else
-ui_merge_id UIManager::add_ui_from_file(const Glib::ustring& filename, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  ui_merge_id retvalue = gtk_ui_manager_add_ui_from_file(gobj(), filename.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
+  Glib::RefPtr<const Action> retvalue = Glib::wrap(gtk_ui_manager_get_action(const_cast<GtkUIManager*>(gobj()), path.c_str()));
 
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
+}
 
+ui_merge_id UIManager::add_ui_from_file(const Glib::ustring& filename)
+{
+  GError *error = 0;
+  ui_merge_id retvalue = gtk_ui_manager_add_ui_from_file(gobj(), filename.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
+  return retvalue;
 }
 
 void UIManager::add_ui(ui_merge_id merge_id, const Glib::ustring& path, const Glib::ustring& name, const Glib::ustring& action, UIManagerItemType type, bool top)
 {
-gtk_ui_manager_add_ui(gobj(), merge_id, path.c_str(), name.c_str(), action.c_str(), ((GtkUIManagerItemType)(type)), static_cast<int>(top)); 
+  gtk_ui_manager_add_ui(gobj(), merge_id, path.c_str(), name.c_str(), action.c_str(), ((GtkUIManagerItemType)(type)), static_cast<int>(top));
 }
 
 void UIManager::remove_ui(ui_merge_id merge_id)
 {
-gtk_ui_manager_remove_ui(gobj(), merge_id); 
+  gtk_ui_manager_remove_ui(gobj(), merge_id);
 }
 
 Glib::ustring UIManager::get_ui() const
@@ -552,7 +499,7 @@ Glib::ustring UIManager::get_ui() const
 
 void UIManager::ensure_update()
 {
-gtk_ui_manager_ensure_update(gobj()); 
+  gtk_ui_manager_ensure_update(gobj());
 }
 
 ui_merge_id UIManager::new_merge_id()
@@ -566,60 +513,48 @@ Glib::SignalProxy1< void,Widget* > UIManager::signal_add_widget()
   return Glib::SignalProxy1< void,Widget* >(this, &UIManager_signal_add_widget_info);
 }
 
-
 Glib::SignalProxy0< void > UIManager::signal_actions_changed()
 {
   return Glib::SignalProxy0< void >(this, &UIManager_signal_actions_changed_info);
 }
 
-
 Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > UIManager::signal_connect_proxy()
 {
   return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &UIManager_signal_connect_proxy_info);
 }
 
-
 Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > UIManager::signal_disconnect_proxy()
 {
   return Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* >(this, &UIManager_signal_disconnect_proxy_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > UIManager::signal_pre_activate()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &UIManager_signal_pre_activate_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > UIManager::signal_post_activate()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Action>& >(this, &UIManager_signal_post_activate_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> UIManager::property_add_tearoffs() 
 {
   return Glib::PropertyProxy<bool>(this, "add-tearoffs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> UIManager::property_add_tearoffs() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "add-tearoffs");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> UIManager::property_ui() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "ui");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::UIManager::on_add_widget(Widget* widget)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -629,6 +564,7 @@ void Gtk::UIManager::on_add_widget(Widget* widget)
   if(base && base->add_widget)
     (*base->add_widget)(gobj(),(GtkWidget*)Glib::unwrap(widget));
 }
+
 void Gtk::UIManager::on_actions_changed()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -638,10 +574,6 @@ void Gtk::UIManager::on_actions_changed()
   if(base && base->actions_changed)
     (*base->actions_changed)(gobj());
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/uimanager.h b/libs/gtkmm2/gtk/gtkmm/uimanager.h
index 9abb6c714e..3adec8c251 100644
--- a/libs/gtkmm2/gtk/gtkmm/uimanager.h
+++ b/libs/gtkmm2/gtk/gtkmm/uimanager.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_UIMANAGER_H
 #define _GTKMM_UIMANAGER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -177,7 +176,7 @@ public:
    * Note that this only affects regular menus. Generated popup 
    * menus never have tearoff menu items.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param add_tearoffs Whether tearoff menu items are added.
    */
   void set_add_tearoffs(bool add_tearoffs = true);
@@ -186,7 +185,7 @@ public:
    * will have tearoff menu items.
    * @return Whether tearoff menu items are added
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_add_tearoffs() const;
   
@@ -194,7 +193,7 @@ public:
    * with @a self . Actions in earlier groups hide actions with the same 
    * name in later groups. 
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param action_group The action group to be inserted.
    * @param pos The position at which the group will be inserted.
    */
@@ -203,7 +202,7 @@ public:
   /** Removes an action group from the list of action groups associated 
    * with @a self .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param action_group The action group to be removed.
    */
   void remove_action_group(const Glib::RefPtr<ActionGroup>& action_group);
@@ -213,7 +212,7 @@ public:
    * @return A G::List of action groups. The list is owned by GTK+ 
    * and should not be modified.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ListHandle< Glib::RefPtr<ActionGroup> > get_action_groups();
   
@@ -221,7 +220,7 @@ public:
    * @return A G::List of action groups. The list is owned by GTK+ 
    * and should not be modified.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ListHandle< Glib::RefPtr<const ActionGroup> > get_action_groups() const;
   
@@ -229,14 +228,14 @@ public:
   /** Returns the Gtk::AccelGroup associated with @a self .
    * @return The Gtk::AccelGroup.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<AccelGroup> get_accel_group();
   
   /** Returns the Gtk::AccelGroup associated with @a self .
    * @return The Gtk::AccelGroup.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const AccelGroup> get_accel_group() const;
   
@@ -248,16 +247,11 @@ public:
    * 
    * Note that the widget found by following a path that ends in a &lt;menu&gt;
    * element is the menuitem to which the menu is attached, not the menu itself.
-   * 
-   * Also note that the widgets constructed by a ui manager are not tied to 
-   * the lifecycle of the ui manager. If you add the widgets returned by this 
-   * function to some container or explicitly ref them, they will survive the
-   * destruction of the ui manager.
    * @param path A path.
    * @return The widget found by following the path, or <tt>0</tt> if no widget
    * was found.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Widget* get_widget(const Glib::ustring& path);
   
@@ -269,16 +263,11 @@ public:
    * 
    * Note that the widget found by following a path that ends in a &lt;menu&gt;
    * element is the menuitem to which the menu is attached, not the menu itself.
-   * 
-   * Also note that the widgets constructed by a ui manager are not tied to 
-   * the lifecycle of the ui manager. If you add the widgets returned by this 
-   * function to some container or explicitly ref them, they will survive the
-   * destruction of the ui manager.
    * @param path A path.
    * @return The widget found by following the path, or <tt>0</tt> if no widget
    * was found.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   const Widget* get_widget(const Glib::ustring& path) const;
 
@@ -290,7 +279,7 @@ public:
    * @return A newly-allocated of all toplevel widgets of the requested 
    * types. 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle<Widget*> get_toplevels(UIManagerItemType types);
   
@@ -301,7 +290,7 @@ public:
    * @return A newly-allocated of all toplevel widgets of the requested 
    * types. 
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::SListHandle<const Widget*> get_toplevels(UIManagerItemType types) const;
                  
@@ -312,7 +301,7 @@ public:
    * @return The action whose proxy widget is found by following the path, 
    * or <tt>0</tt> if no widget was found.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<Action> get_action(const Glib::ustring& path);
   
@@ -322,7 +311,7 @@ public:
    * @return The action whose proxy widget is found by following the path, 
    * or <tt>0</tt> if no widget was found.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::RefPtr<const Action> get_action(const Glib::ustring& path) const;
 
@@ -335,13 +324,9 @@ public:
    * @param buffer the string to parse
    * @result  The merge id for the merged UI. The merge id can be used to unmerge the UI with remove_ui(). If an error occurred, the return value is 0.
    * @throws exception
-   * @newin2p4
+   * Since: 2.4
    */ 
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   ui_merge_id add_ui_from_string(const Glib::ustring& buffer);
-  #else
-  ui_merge_id add_ui_from_string(const Glib::ustring& buffer, std::auto_ptr<Glib::Error>& error);
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
   
   
   /** Parses a file containing a UI definition and 
@@ -351,14 +336,9 @@ public:
    * to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred,
    * the return value is 0.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   ui_merge_id add_ui_from_file(const Glib::ustring& filename);
-#else
-  ui_merge_id add_ui_from_file(const Glib::ustring& filename, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
 //TODO: Is top=true a good default?
 
@@ -372,7 +352,7 @@ public:
    * 
    *  @a see  add_ui_separator().
    * 
-   *  @a newin2p4 
+   * Since: 2.4
    * @param merge_id The merge id for the merged UI, see gtk_ui_manager_new_merge_id().
    * @param path A path.
    * @param name The name for the added UI element.
@@ -392,7 +372,7 @@ public:
    *
    * @see add_ui().
    *
-   * @newin2p4
+   * Since: 2.4
    * @param merge_id The merge id for the merged UI, see gtk_ui_manager_new_merge_id().
    * @param path A path.
    * @param name The name for the added UI element.
@@ -405,7 +385,7 @@ public:
   
   /** Unmerges the part of @a self &lt;!-- --&gt;s content identified by @a merge_id .
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param merge_id A merge id as returned by gtk_ui_manager_add_ui_from_string().
    */
   void remove_ui(ui_merge_id merge_id);
@@ -414,7 +394,7 @@ public:
    * @return A newly allocated string containing an XML representation of 
    * the merged UI.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ustring get_ui() const;
   
@@ -436,7 +416,7 @@ public:
    * 
    * @endcode
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void ensure_update();
   
@@ -444,116 +424,37 @@ public:
    * gtk_ui_manager_add_ui().
    * @return An unused merge id.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   ui_merge_id new_merge_id();
 
-  /** The add_widget signal is emitted for each generated menubar and toolbar.
-   * It is not emitted for generated popup menus, which can be obtained by 
-   * get_widget().
-   * 
-   * @param widget the added widget
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %add_widget(Widget* widget)</tt>
-   */
 
   Glib::SignalProxy1< void,Widget* > signal_add_widget();
 
   
-  /** The "actions-changed" signal is emitted whenever the set of actions
-   * changes.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %actions_changed()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_actions_changed();
 
   
-  /** The connect_proxy signal is emitted after connecting a proxy to 
-   * an action in the group. 
-   *
-   * This is intended for simple customizations for which a custom action
-   * class would be too clumsy, e.g. showing tooltips for menuitems in the
-   * statusbar.
-   *
-   * @param action the action
-   * @param widget the proxy
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %connect_proxy(const Glib::RefPtr<Action>& action, Widget* widget)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_connect_proxy();
 
   
-  /** The disconnect_proxy signal is emitted after disconnecting a proxy 
-   * from an action in the group. 
-   *
-   * @param action the action
-   * @param widget the proxy
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %disconnect_proxy(const Glib::RefPtr<Action>& action, Widget* widget)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::RefPtr<Action>&,Widget* > signal_disconnect_proxy();
 
   
-  /** The pre_activate signal is emitted just before the @a action
-   * is activated.
-   *
-   * This is intended for applications to get notification
-   * just before any action is activated.
-   *
-   * @param action the action
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %pre_activate(const Glib::RefPtr<Action>& action)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_pre_activate();
 
   
-  /** The post_activate signal is emitted just after the @a action
-   * is activated.
-   *
-   * This is intended for applications to get notification
-   * just after any action is activated.
-   *
-   * @param action the action
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %post_activate(const Glib::RefPtr<Action>& action)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Action>& > signal_post_activate();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether tearoff menu items should be added to menus.
+  /** Whether tearoff menu items should be added to menus.
    *
    * 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_add_tearoffs() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether tearoff menu items should be added to menus.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -561,36 +462,27 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_add_tearoffs() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** An XML string describing the merged UI.
+  /** An XML string describing the merged UI.
    *
    * 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_ui() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_add_widget(Widget* widget);
   virtual void on_actions_changed();
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/gtk/gtkmm/viewport.cc b/libs/gtkmm2/gtk/gtkmm/viewport.cc
index f908ea78e9..c06abb80aa 100644
--- a/libs/gtkmm2/gtk/gtkmm/viewport.cc
+++ b/libs/gtkmm2/gtk/gtkmm/viewport.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/viewport.h>
 #include <gtkmm/private/viewport_p.h>
 
@@ -30,11 +29,11 @@
 #include <gtkmm/adjustment.h>
 #include <gtk/gtkviewport.h>
 
+
 namespace
 {
 
-
-static void Viewport_signal_set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
+void Viewport_signal_set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0,GtkAdjustment* p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Gtk::Adjustment*,Gtk::Adjustment* > SlotType;
@@ -42,32 +41,27 @@ static void Viewport_signal_set_scroll_adjustments_callback(GtkViewport* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Viewport_signal_set_scroll_adjustments_info =
+const Glib::SignalProxyInfo Viewport_signal_set_scroll_adjustments_info =
 {
   "set_scroll_adjustments",
   (GCallback) &Viewport_signal_set_scroll_adjustments_callback,
   (GCallback) &Viewport_signal_set_scroll_adjustments_callback
 };
 
-
 } // anonymous namespace
 
 
@@ -112,18 +106,10 @@ void Viewport_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->set_scroll_adjustments = &set_scroll_adjustments_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Viewport_Class::set_scroll_adjustments_callback(GtkViewport* self, GtkAdjustment* p0, GtkAdjustment* p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -136,21 +122,17 @@ void Viewport_Class::set_scroll_adjustments_callback(GtkViewport* self, GtkAdjus
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_scroll_adjustments(Glib::wrap(p0)
 , Glib::wrap(p1)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -163,7 +145,6 @@ void Viewport_Class::set_scroll_adjustments_callback(GtkViewport* self, GtkAdjus
       (*base->set_scroll_adjustments)(self, p0, p1);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Viewport_Class::wrap_new(GObject* o)
@@ -219,7 +200,7 @@ Gtk::Adjustment* Viewport::get_hadjustment()
 
 const Gtk::Adjustment* Viewport::get_hadjustment() const
 {
-  return const_cast<Viewport*>(this)->get_hadjustment();
+  return Glib::wrap(gtk_viewport_get_hadjustment(const_cast<GtkViewport*>(gobj())));
 }
 
 Gtk::Adjustment* Viewport::get_vadjustment()
@@ -229,32 +210,32 @@ Gtk::Adjustment* Viewport::get_vadjustment()
 
 const Gtk::Adjustment* Viewport::get_vadjustment() const
 {
-  return const_cast<Viewport*>(this)->get_vadjustment();
+  return Glib::wrap(gtk_viewport_get_vadjustment(const_cast<GtkViewport*>(gobj())));
 }
 
 void Viewport::set_hadjustment(Gtk::Adjustment* adjustment)
 {
-gtk_viewport_set_hadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(adjustment)); 
+  gtk_viewport_set_hadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(adjustment));
 }
 
 void Viewport::set_hadjustment(Gtk::Adjustment& adjustment)
 {
-gtk_viewport_set_hadjustment(gobj(), (adjustment).gobj()); 
+  gtk_viewport_set_hadjustment(gobj(), (adjustment).gobj());
 }
 
 void Viewport::set_vadjustment(Gtk::Adjustment* adjustment)
 {
-gtk_viewport_set_vadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(adjustment)); 
+  gtk_viewport_set_vadjustment(gobj(), (GtkAdjustment*)Glib::unwrap(adjustment));
 }
 
 void Viewport::set_vadjustment(Gtk::Adjustment& adjustment)
 {
-gtk_viewport_set_vadjustment(gobj(), (adjustment).gobj()); 
+  gtk_viewport_set_vadjustment(gobj(), (adjustment).gobj());
 }
 
 void Viewport::set_shadow_type(ShadowType type)
 {
-gtk_viewport_set_shadow_type(gobj(), ((GtkShadowType)(type))); 
+  gtk_viewport_set_shadow_type(gobj(), ((GtkShadowType)(type)));
 }
 
 ShadowType Viewport::get_shadow_type() const
@@ -269,50 +250,37 @@ Glib::SignalProxy2< void,Gtk::Adjustment*,Gtk::Adjustment* > Viewport::signal_se
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Adjustment*> Viewport::property_hadjustment() 
 {
   return Glib::PropertyProxy<Gtk::Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> Viewport::property_hadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "hadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Adjustment*> Viewport::property_vadjustment() 
 {
   return Glib::PropertyProxy<Gtk::Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> Viewport::property_vadjustment() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*>(this, "vadjustment");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ShadowType> Viewport::property_shadow_type() 
 {
   return Glib::PropertyProxy<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ShadowType> Viewport::property_shadow_type() const
 {
   return Glib::PropertyProxy_ReadOnly<ShadowType>(this, "shadow-type");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Viewport::on_set_scroll_adjustments(Gtk::Adjustment* hadjustment, Gtk::Adjustment* vadjustment)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -322,10 +290,6 @@ void Gtk::Viewport::on_set_scroll_adjustments(Gtk::Adjustment* hadjustment, Gtk:
   if(base && base->set_scroll_adjustments)
     (*base->set_scroll_adjustments)(gobj(),(GtkAdjustment*)Glib::unwrap(hadjustment),(GtkAdjustment*)Glib::unwrap(vadjustment));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/viewport.h b/libs/gtkmm2/gtk/gtkmm/viewport.h
index 1b9714587c..42d429c15d 100644
--- a/libs/gtkmm2/gtk/gtkmm/viewport.h
+++ b/libs/gtkmm2/gtk/gtkmm/viewport.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_VIEWPORT_H
 #define _GTKMM_VIEWPORT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -90,18 +89,12 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_set_scroll_adjustments(Gtk::Adjustment* hadjustment, Gtk::Adjustment* vadjustment);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -168,25 +161,17 @@ public:
   ShadowType get_shadow_type() const;
 
   
-/**
-   * @par Prototype:
-   * <tt>void %set_scroll_adjustments(Gtk::Adjustment* hadjustment, Gtk::Adjustment* vadjustment)</tt>
-   */
-
   Glib::SignalProxy2< void,Gtk::Adjustment*,Gtk::Adjustment* > signal_set_scroll_adjustments();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkAdjustment that determines the values of the horizontal position for this viewport.
+  /** The GtkAdjustment that determines the values of the horizontal position for this viewport.
    *
    * 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::Adjustment*> property_hadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkAdjustment that determines the values of the horizontal position for this viewport.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -194,19 +179,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_hadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The GtkAdjustment that determines the values of the vertical position for this viewport.
+  /** The GtkAdjustment that determines the values of the vertical position for this viewport.
    *
    * 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::Adjustment*> property_vadjustment() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The GtkAdjustment that determines the values of the vertical position for this viewport.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -214,19 +195,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Adjustment*> property_vadjustment() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Determines how the shadowed box around the viewport is drawn.
+  /** Determines how the shadowed box around the viewport is drawn.
    *
    * 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<ShadowType> property_shadow_type() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Determines how the shadowed box around the viewport is drawn.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -234,7 +211,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ShadowType> property_shadow_type() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -250,8 +226,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Viewport* wrap(GtkViewport* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_VIEWPORT_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/widget.cc b/libs/gtkmm2/gtk/gtkmm/widget.cc
index f756f57c9a..eabf1ed4a8 100644
--- a/libs/gtkmm2/gtk/gtkmm/widget.cc
+++ b/libs/gtkmm2/gtk/gtkmm/widget.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/widget.h>
 #include <gtkmm/private/widget_p.h>
 
@@ -32,13 +31,11 @@
 #include <gtkmm/style.h>
 #include <gtkmm/container.h>
 #include <gtkmm/selectiondata_private.h>
-#include <gtkmm/action.h>
 #include <gtk/gtkdnd.h>
 #include <gtk/gtkselection.h>
 #include <gtk/gtkwidget.h>
 #include <gtk/gtkcontainer.h>
 #include <gtk/gtkmain.h>
-#include <gtk/gtkaction.h> //For gtk_widget_get_action().
 
 
 namespace //anonymous
@@ -46,7 +43,7 @@ namespace //anonymous
 
 //These signal callbacks are custom implemented, so that we can create a temporary SelectionData instance.
 //To do this, we used the optional custom_c_callback paramater to _WRAP_SIGNAL() in the .hg file.
-static void Widget_signal_drag_data_get_callback(GtkWidget* self, GdkDragContext* p0,GtkSelectionData* p1,guint p2,guint p3,void* data)
+void Widget_signal_drag_data_get_callback(GtkWidget* self, GdkDragContext* p0,GtkSelectionData* p1,guint p2,guint p3,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > SlotType;
@@ -54,26 +51,22 @@ static void Widget_signal_drag_data_get_callback(GtkWidget* self, GdkDragContext
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
       {
         SelectionData_WithoutOwnership temp_instance(p1);
         (*static_cast<SlotType*>(slot))( Glib::wrap(p0, true), temp_instance, p2, p3 );
       }
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static void Widget_signal_selection_get_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,guint p2,void* data)
+void Widget_signal_selection_get_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,guint p2,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void, SelectionData&, guint, guint > SlotType;
@@ -81,22 +74,18 @@ static void Widget_signal_selection_get_callback(GtkWidget* self, GtkSelectionDa
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
       {
         SelectionData_WithoutOwnership temp_instance(p0);
         (*static_cast<SlotType*>(slot))( temp_instance, p1, p2 );
       }
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
@@ -106,7 +95,6 @@ static void Widget_signal_selection_get_callback(GtkWidget* self, GtkSelectionDa
 namespace Gtk
 {
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 //These default handler callbacks are custom implemented, so that we can create a temporary SelectionData instance.
 //To do this, we used the optional custom_c_callback paramater to _WRAP_SIGNAL() in the .hg file.
 void Widget_Class::selection_get_callback(GtkWidget* self, GtkSelectionData* p0, guint p1, guint p2)
@@ -121,20 +109,16 @@ void Widget_Class::selection_get_callback(GtkWidget* self, GtkSelectionData* p0,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       SelectionData_WithoutOwnership temp_instance(p0);
       obj->on_selection_get(temp_instance, p1, p2);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -160,20 +144,16 @@ void Widget_Class::drag_data_get_callback(GtkWidget* self, GdkDragContext* p0, G
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       SelectionData_WithoutOwnership temp_instance(p1);
       obj->on_drag_data_get(Glib::wrap(p0, true), temp_instance, p2, p3);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -186,7 +166,6 @@ void Widget_Class::drag_data_get_callback(GtkWidget* self, GdkDragContext* p0, G
       (*base->drag_data_get)(self, p0, p1, p2, p3);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 Widget::~Widget()
 {}
@@ -392,7 +371,6 @@ void Widget::drag_set_as_icon(const Glib::RefPtr<Gdk::DragContext>& context, int
   gtk_drag_set_icon_widget(Glib::unwrap(context), gobj(), hot_x, hot_y);
 }
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Widget_Class::hierarchy_changed_callback_custom(GtkWidget* self, GtkWidget* p0)
 {
   //GTKMM_LIFECYCLE
@@ -438,7 +416,6 @@ void Widget_Class::parent_set_callback_custom(GtkWidget* self, GtkWidget* p0)
       (*base->parent_set)(self, p0);
   }
 }
-#endif //#GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 void Widget_Class::dispose_vfunc_callback(GObject* self)
 {
@@ -551,11 +528,6 @@ void Widget::unset_shape_combine_mask()
   gtk_widget_shape_combine_mask(gobj(), 0, 0, 0); /* See GTK+ docs */
 }
 
-void Widget::unset_input_shape_combine_mask()
-{            
-  gtk_widget_input_shape_combine_mask(gobj(), 0, 0, 0); /* See GTK+ docs */
-}
-
 void Widget::draw_insertion_cursor(Glib::RefPtr<Gdk::Drawable> drawable, const Gdk::Rectangle& area, const Gdk::Rectangle& location, bool is_primary, TextDirection direction, bool draw_arrow)
 {
   gtk_draw_insertion_cursor(gobj(), drawable->gobj(), const_cast<GdkRectangle*>(area.gobj()), const_cast<GdkRectangle*>(location.gobj()), is_primary, (GtkTextDirection)direction, draw_arrow);
@@ -575,8 +547,7 @@ Requisition Widget::size_request() const
 namespace
 {
 
-
-static const Glib::SignalProxyInfo Widget_signal_show_info =
+const Glib::SignalProxyInfo Widget_signal_show_info =
 {
   "show",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -584,7 +555,7 @@ static const Glib::SignalProxyInfo Widget_signal_show_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_hide_info =
+const Glib::SignalProxyInfo Widget_signal_hide_info =
 {
   "hide",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -592,7 +563,7 @@ static const Glib::SignalProxyInfo Widget_signal_hide_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_map_info =
+const Glib::SignalProxyInfo Widget_signal_map_info =
 {
   "map",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -600,7 +571,7 @@ static const Glib::SignalProxyInfo Widget_signal_map_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_unmap_info =
+const Glib::SignalProxyInfo Widget_signal_unmap_info =
 {
   "unmap",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -608,7 +579,7 @@ static const Glib::SignalProxyInfo Widget_signal_unmap_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_realize_info =
+const Glib::SignalProxyInfo Widget_signal_realize_info =
 {
   "realize",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -616,7 +587,7 @@ static const Glib::SignalProxyInfo Widget_signal_realize_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_unrealize_info =
+const Glib::SignalProxyInfo Widget_signal_unrealize_info =
 {
   "unrealize",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -624,7 +595,7 @@ static const Glib::SignalProxyInfo Widget_signal_unrealize_info =
 };
 
 
-static void Widget_signal_size_request_callback(GtkWidget* self, GtkRequisition* p0,void* data)
+void Widget_signal_size_request_callback(GtkWidget* self, GtkRequisition* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Requisition* > SlotType;
@@ -632,24 +603,20 @@ static void Widget_signal_size_request_callback(GtkWidget* self, GtkRequisition*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))((Requisition*)(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_size_request_info =
+const Glib::SignalProxyInfo Widget_signal_size_request_info =
 {
   "size_request",
   (GCallback) &Widget_signal_size_request_callback,
@@ -657,7 +624,7 @@ static const Glib::SignalProxyInfo Widget_signal_size_request_info =
 };
 
 
-static void Widget_signal_size_allocate_callback(GtkWidget* self, GtkAllocation* p0,void* data)
+void Widget_signal_size_allocate_callback(GtkWidget* self, GtkAllocation* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Allocation& > SlotType;
@@ -665,24 +632,20 @@ static void Widget_signal_size_allocate_callback(GtkWidget* self, GtkAllocation*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))((Allocation&)(Glib::wrap(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_size_allocate_info =
+const Glib::SignalProxyInfo Widget_signal_size_allocate_info =
 {
   "size_allocate",
   (GCallback) &Widget_signal_size_allocate_callback,
@@ -690,7 +653,7 @@ static const Glib::SignalProxyInfo Widget_signal_size_allocate_info =
 };
 
 
-static void Widget_signal_state_changed_callback(GtkWidget* self, GtkStateType p0,void* data)
+void Widget_signal_state_changed_callback(GtkWidget* self, GtkStateType p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Gtk::StateType > SlotType;
@@ -698,24 +661,20 @@ static void Widget_signal_state_changed_callback(GtkWidget* self, GtkStateType p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((Gtk::StateType)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_state_changed_info =
+const Glib::SignalProxyInfo Widget_signal_state_changed_info =
 {
   "state_changed",
   (GCallback) &Widget_signal_state_changed_callback,
@@ -723,7 +682,7 @@ static const Glib::SignalProxyInfo Widget_signal_state_changed_info =
 };
 
 
-static void Widget_signal_parent_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
+void Widget_signal_parent_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -731,24 +690,20 @@ static void Widget_signal_parent_changed_callback(GtkWidget* self, GtkWidget* p0
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_parent_changed_info =
+const Glib::SignalProxyInfo Widget_signal_parent_changed_info =
 {
   "parent_set",
   (GCallback) &Widget_signal_parent_changed_callback,
@@ -756,7 +711,7 @@ static const Glib::SignalProxyInfo Widget_signal_parent_changed_info =
 };
 
 
-static void Widget_signal_hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
+void Widget_signal_hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -764,24 +719,20 @@ static void Widget_signal_hierarchy_changed_callback(GtkWidget* self, GtkWidget*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_hierarchy_changed_info =
+const Glib::SignalProxyInfo Widget_signal_hierarchy_changed_info =
 {
   "hierarchy_changed",
   (GCallback) &Widget_signal_hierarchy_changed_callback,
@@ -789,7 +740,7 @@ static const Glib::SignalProxyInfo Widget_signal_hierarchy_changed_info =
 };
 
 
-static void Widget_signal_style_changed_callback(GtkWidget* self, GtkStyle* p0,void* data)
+void Widget_signal_style_changed_callback(GtkWidget* self, GtkStyle* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Style>& > SlotType;
@@ -797,24 +748,20 @@ static void Widget_signal_style_changed_callback(GtkWidget* self, GtkStyle* p0,v
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_style_changed_info =
+const Glib::SignalProxyInfo Widget_signal_style_changed_info =
 {
   "style_set",
   (GCallback) &Widget_signal_style_changed_callback,
@@ -822,7 +769,7 @@ static const Glib::SignalProxyInfo Widget_signal_style_changed_info =
 };
 
 
-static void Widget_signal_direction_changed_callback(GtkWidget* self, GtkTextDirection p0,void* data)
+void Widget_signal_direction_changed_callback(GtkWidget* self, GtkTextDirection p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,TextDirection > SlotType;
@@ -830,24 +777,20 @@ static void Widget_signal_direction_changed_callback(GtkWidget* self, GtkTextDir
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((TextDirection)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_direction_changed_info =
+const Glib::SignalProxyInfo Widget_signal_direction_changed_info =
 {
   "direction_changed",
   (GCallback) &Widget_signal_direction_changed_callback,
@@ -855,7 +798,7 @@ static const Glib::SignalProxyInfo Widget_signal_direction_changed_info =
 };
 
 
-static void Widget_signal_grab_notify_callback(GtkWidget* self, gboolean p0,void* data)
+void Widget_signal_grab_notify_callback(GtkWidget* self, gboolean p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,bool > SlotType;
@@ -863,24 +806,20 @@ static void Widget_signal_grab_notify_callback(GtkWidget* self, gboolean p0,void
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_grab_notify_info =
+const Glib::SignalProxyInfo Widget_signal_grab_notify_info =
 {
   "grab_notify",
   (GCallback) &Widget_signal_grab_notify_callback,
@@ -888,7 +827,7 @@ static const Glib::SignalProxyInfo Widget_signal_grab_notify_info =
 };
 
 
-static void Widget_signal_child_notify_callback(GtkWidget* self, GParamSpec* p0,void* data)
+void Widget_signal_child_notify_callback(GtkWidget* self, GParamSpec* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GParamSpec* > SlotType;
@@ -896,23 +835,19 @@ static void Widget_signal_child_notify_callback(GtkWidget* self, GParamSpec* p0,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_child_notify_info =
+const Glib::SignalProxyInfo Widget_signal_child_notify_info =
 {
   "child_notify",
   (GCallback) &Widget_signal_child_notify_callback,
@@ -920,7 +855,7 @@ static const Glib::SignalProxyInfo Widget_signal_child_notify_info =
 };
 
 
-static gboolean Widget_signal_mnemonic_activate_callback(GtkWidget* self, gboolean p0,void* data)
+gboolean Widget_signal_mnemonic_activate_callback(GtkWidget* self, gboolean p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,bool > SlotType;
@@ -928,27 +863,23 @@ static gboolean Widget_signal_mnemonic_activate_callback(GtkWidget* self, gboole
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_mnemonic_activate_notify_callback(GtkWidget* self, gboolean p0, void* data)
+gboolean Widget_signal_mnemonic_activate_notify_callback(GtkWidget* self, gboolean p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,bool > SlotType;
@@ -956,27 +887,23 @@ static gboolean Widget_signal_mnemonic_activate_notify_callback(GtkWidget* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_mnemonic_activate_info =
+const Glib::SignalProxyInfo Widget_signal_mnemonic_activate_info =
 {
   "mnemonic_activate",
   (GCallback) &Widget_signal_mnemonic_activate_callback,
@@ -984,7 +911,7 @@ static const Glib::SignalProxyInfo Widget_signal_mnemonic_activate_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_grab_focus_info =
+const Glib::SignalProxyInfo Widget_signal_grab_focus_info =
 {
   "grab_focus",
   (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
@@ -992,7 +919,7 @@ static const Glib::SignalProxyInfo Widget_signal_grab_focus_info =
 };
 
 
-static gboolean Widget_signal_focus_callback(GtkWidget* self, GtkDirectionType p0,void* data)
+gboolean Widget_signal_focus_callback(GtkWidget* self, GtkDirectionType p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,DirectionType > SlotType;
@@ -1000,27 +927,23 @@ static gboolean Widget_signal_focus_callback(GtkWidget* self, GtkDirectionType p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(((DirectionType)(p0))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_focus_notify_callback(GtkWidget* self, GtkDirectionType p0, void* data)
+gboolean Widget_signal_focus_notify_callback(GtkWidget* self, GtkDirectionType p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,DirectionType > SlotType;
@@ -1028,27 +951,23 @@ static gboolean Widget_signal_focus_notify_callback(GtkWidget* self, GtkDirectio
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(((DirectionType)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_focus_info =
+const Glib::SignalProxyInfo Widget_signal_focus_info =
 {
   "focus",
   (GCallback) &Widget_signal_focus_callback,
@@ -1056,7 +975,7 @@ static const Glib::SignalProxyInfo Widget_signal_focus_info =
 };
 
 
-static gboolean Widget_signal_event_callback(GtkWidget* self, GdkEvent* p0,void* data)
+gboolean Widget_signal_event_callback(GtkWidget* self, GdkEvent* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEvent* > SlotType;
@@ -1064,26 +983,22 @@ static gboolean Widget_signal_event_callback(GtkWidget* self, GdkEvent* p0,void*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_event_notify_callback(GtkWidget* self, GdkEvent* p0, void* data)
+gboolean Widget_signal_event_notify_callback(GtkWidget* self, GdkEvent* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEvent* > SlotType;
@@ -1091,26 +1006,22 @@ static gboolean Widget_signal_event_notify_callback(GtkWidget* self, GdkEvent* p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_event_info =
+const Glib::SignalProxyInfo Widget_signal_event_info =
 {
   "event",
   (GCallback) &Widget_signal_event_callback,
@@ -1118,7 +1029,7 @@ static const Glib::SignalProxyInfo Widget_signal_event_info =
 };
 
 
-static void Widget_signal_event_after_callback(GtkWidget* self, GdkEvent* p0,void* data)
+void Widget_signal_event_after_callback(GtkWidget* self, GdkEvent* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEvent* > SlotType;
@@ -1126,23 +1037,19 @@ static void Widget_signal_event_after_callback(GtkWidget* self, GdkEvent* p0,voi
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_event_after_info =
+const Glib::SignalProxyInfo Widget_signal_event_after_info =
 {
   "event_after",
   (GCallback) &Widget_signal_event_after_callback,
@@ -1150,7 +1057,7 @@ static const Glib::SignalProxyInfo Widget_signal_event_after_info =
 };
 
 
-static gboolean Widget_signal_button_press_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
+gboolean Widget_signal_button_press_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventButton* > SlotType;
@@ -1158,26 +1065,22 @@ static gboolean Widget_signal_button_press_event_callback(GtkWidget* self, GdkEv
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_button_press_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
+gboolean Widget_signal_button_press_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventButton* > SlotType;
@@ -1185,26 +1088,22 @@ static gboolean Widget_signal_button_press_event_notify_callback(GtkWidget* self
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_button_press_event_info =
+const Glib::SignalProxyInfo Widget_signal_button_press_event_info =
 {
   "button_press_event",
   (GCallback) &Widget_signal_button_press_event_callback,
@@ -1212,7 +1111,7 @@ static const Glib::SignalProxyInfo Widget_signal_button_press_event_info =
 };
 
 
-static gboolean Widget_signal_button_release_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
+gboolean Widget_signal_button_release_event_callback(GtkWidget* self, GdkEventButton* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventButton* > SlotType;
@@ -1220,26 +1119,22 @@ static gboolean Widget_signal_button_release_event_callback(GtkWidget* self, Gdk
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_button_release_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
+gboolean Widget_signal_button_release_event_notify_callback(GtkWidget* self, GdkEventButton* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventButton* > SlotType;
@@ -1247,26 +1142,22 @@ static gboolean Widget_signal_button_release_event_notify_callback(GtkWidget* se
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_button_release_event_info =
+const Glib::SignalProxyInfo Widget_signal_button_release_event_info =
 {
   "button_release_event",
   (GCallback) &Widget_signal_button_release_event_callback,
@@ -1274,7 +1165,7 @@ static const Glib::SignalProxyInfo Widget_signal_button_release_event_info =
 };
 
 
-static gboolean Widget_signal_scroll_event_callback(GtkWidget* self, GdkEventScroll* p0,void* data)
+gboolean Widget_signal_scroll_event_callback(GtkWidget* self, GdkEventScroll* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventScroll* > SlotType;
@@ -1282,26 +1173,22 @@ static gboolean Widget_signal_scroll_event_callback(GtkWidget* self, GdkEventScr
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_scroll_event_notify_callback(GtkWidget* self, GdkEventScroll* p0, void* data)
+gboolean Widget_signal_scroll_event_notify_callback(GtkWidget* self, GdkEventScroll* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventScroll* > SlotType;
@@ -1309,26 +1196,22 @@ static gboolean Widget_signal_scroll_event_notify_callback(GtkWidget* self, GdkE
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_scroll_event_info =
+const Glib::SignalProxyInfo Widget_signal_scroll_event_info =
 {
   "scroll_event",
   (GCallback) &Widget_signal_scroll_event_callback,
@@ -1336,7 +1219,7 @@ static const Glib::SignalProxyInfo Widget_signal_scroll_event_info =
 };
 
 
-static gboolean Widget_signal_motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0,void* data)
+gboolean Widget_signal_motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventMotion* > SlotType;
@@ -1344,26 +1227,22 @@ static gboolean Widget_signal_motion_notify_event_callback(GtkWidget* self, GdkE
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_motion_notify_event_notify_callback(GtkWidget* self, GdkEventMotion* p0, void* data)
+gboolean Widget_signal_motion_notify_event_notify_callback(GtkWidget* self, GdkEventMotion* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventMotion* > SlotType;
@@ -1371,26 +1250,22 @@ static gboolean Widget_signal_motion_notify_event_notify_callback(GtkWidget* sel
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_motion_notify_event_info =
+const Glib::SignalProxyInfo Widget_signal_motion_notify_event_info =
 {
   "motion_notify_event",
   (GCallback) &Widget_signal_motion_notify_event_callback,
@@ -1398,7 +1273,7 @@ static const Glib::SignalProxyInfo Widget_signal_motion_notify_event_info =
 };
 
 
-static gboolean Widget_signal_delete_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+gboolean Widget_signal_delete_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventAny* > SlotType;
@@ -1406,26 +1281,22 @@ static gboolean Widget_signal_delete_event_callback(GtkWidget* self, GdkEventAny
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_delete_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+gboolean Widget_signal_delete_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventAny* > SlotType;
@@ -1433,26 +1304,22 @@ static gboolean Widget_signal_delete_event_notify_callback(GtkWidget* self, GdkE
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_delete_event_info =
+const Glib::SignalProxyInfo Widget_signal_delete_event_info =
 {
   "delete_event",
   (GCallback) &Widget_signal_delete_event_callback,
@@ -1460,7 +1327,7 @@ static const Glib::SignalProxyInfo Widget_signal_delete_event_info =
 };
 
 
-static gboolean Widget_signal_expose_event_callback(GtkWidget* self, GdkEventExpose* p0,void* data)
+gboolean Widget_signal_expose_event_callback(GtkWidget* self, GdkEventExpose* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventExpose* > SlotType;
@@ -1468,26 +1335,22 @@ static gboolean Widget_signal_expose_event_callback(GtkWidget* self, GdkEventExp
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_expose_event_notify_callback(GtkWidget* self, GdkEventExpose* p0, void* data)
+gboolean Widget_signal_expose_event_notify_callback(GtkWidget* self, GdkEventExpose* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventExpose* > SlotType;
@@ -1495,26 +1358,22 @@ static gboolean Widget_signal_expose_event_notify_callback(GtkWidget* self, GdkE
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_expose_event_info =
+const Glib::SignalProxyInfo Widget_signal_expose_event_info =
 {
   "expose_event",
   (GCallback) &Widget_signal_expose_event_callback,
@@ -1522,7 +1381,7 @@ static const Glib::SignalProxyInfo Widget_signal_expose_event_info =
 };
 
 
-static gboolean Widget_signal_key_press_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
+gboolean Widget_signal_key_press_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventKey* > SlotType;
@@ -1530,26 +1389,22 @@ static gboolean Widget_signal_key_press_event_callback(GtkWidget* self, GdkEvent
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_key_press_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
+gboolean Widget_signal_key_press_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventKey* > SlotType;
@@ -1557,26 +1412,22 @@ static gboolean Widget_signal_key_press_event_notify_callback(GtkWidget* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_key_press_event_info =
+const Glib::SignalProxyInfo Widget_signal_key_press_event_info =
 {
   "key_press_event",
   (GCallback) &Widget_signal_key_press_event_callback,
@@ -1584,7 +1435,7 @@ static const Glib::SignalProxyInfo Widget_signal_key_press_event_info =
 };
 
 
-static gboolean Widget_signal_key_release_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
+gboolean Widget_signal_key_release_event_callback(GtkWidget* self, GdkEventKey* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventKey* > SlotType;
@@ -1592,26 +1443,22 @@ static gboolean Widget_signal_key_release_event_callback(GtkWidget* self, GdkEve
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_key_release_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
+gboolean Widget_signal_key_release_event_notify_callback(GtkWidget* self, GdkEventKey* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventKey* > SlotType;
@@ -1619,26 +1466,22 @@ static gboolean Widget_signal_key_release_event_notify_callback(GtkWidget* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_key_release_event_info =
+const Glib::SignalProxyInfo Widget_signal_key_release_event_info =
 {
   "key_release_event",
   (GCallback) &Widget_signal_key_release_event_callback,
@@ -1646,7 +1489,7 @@ static const Glib::SignalProxyInfo Widget_signal_key_release_event_info =
 };
 
 
-static gboolean Widget_signal_enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
+gboolean Widget_signal_enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventCrossing* > SlotType;
@@ -1654,26 +1497,22 @@ static gboolean Widget_signal_enter_notify_event_callback(GtkWidget* self, GdkEv
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_enter_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
+gboolean Widget_signal_enter_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventCrossing* > SlotType;
@@ -1681,26 +1520,22 @@ static gboolean Widget_signal_enter_notify_event_notify_callback(GtkWidget* self
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_enter_notify_event_info =
+const Glib::SignalProxyInfo Widget_signal_enter_notify_event_info =
 {
   "enter_notify_event",
   (GCallback) &Widget_signal_enter_notify_event_callback,
@@ -1708,7 +1543,7 @@ static const Glib::SignalProxyInfo Widget_signal_enter_notify_event_info =
 };
 
 
-static gboolean Widget_signal_leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
+gboolean Widget_signal_leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventCrossing* > SlotType;
@@ -1716,26 +1551,22 @@ static gboolean Widget_signal_leave_notify_event_callback(GtkWidget* self, GdkEv
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_leave_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
+gboolean Widget_signal_leave_notify_event_notify_callback(GtkWidget* self, GdkEventCrossing* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventCrossing* > SlotType;
@@ -1743,26 +1574,22 @@ static gboolean Widget_signal_leave_notify_event_notify_callback(GtkWidget* self
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_leave_notify_event_info =
+const Glib::SignalProxyInfo Widget_signal_leave_notify_event_info =
 {
   "leave_notify_event",
   (GCallback) &Widget_signal_leave_notify_event_callback,
@@ -1770,7 +1597,7 @@ static const Glib::SignalProxyInfo Widget_signal_leave_notify_event_info =
 };
 
 
-static gboolean Widget_signal_configure_event_callback(GtkWidget* self, GdkEventConfigure* p0,void* data)
+gboolean Widget_signal_configure_event_callback(GtkWidget* self, GdkEventConfigure* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventConfigure* > SlotType;
@@ -1778,26 +1605,22 @@ static gboolean Widget_signal_configure_event_callback(GtkWidget* self, GdkEvent
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_configure_event_notify_callback(GtkWidget* self, GdkEventConfigure* p0, void* data)
+gboolean Widget_signal_configure_event_notify_callback(GtkWidget* self, GdkEventConfigure* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventConfigure* > SlotType;
@@ -1805,26 +1628,22 @@ static gboolean Widget_signal_configure_event_notify_callback(GtkWidget* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_configure_event_info =
+const Glib::SignalProxyInfo Widget_signal_configure_event_info =
 {
   "configure_event",
   (GCallback) &Widget_signal_configure_event_callback,
@@ -1832,7 +1651,7 @@ static const Glib::SignalProxyInfo Widget_signal_configure_event_info =
 };
 
 
-static gboolean Widget_signal_focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
+gboolean Widget_signal_focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventFocus* > SlotType;
@@ -1840,26 +1659,22 @@ static gboolean Widget_signal_focus_in_event_callback(GtkWidget* self, GdkEventF
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_focus_in_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
+gboolean Widget_signal_focus_in_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventFocus* > SlotType;
@@ -1867,26 +1682,22 @@ static gboolean Widget_signal_focus_in_event_notify_callback(GtkWidget* self, Gd
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_focus_in_event_info =
+const Glib::SignalProxyInfo Widget_signal_focus_in_event_info =
 {
   "focus_in_event",
   (GCallback) &Widget_signal_focus_in_event_callback,
@@ -1894,7 +1705,7 @@ static const Glib::SignalProxyInfo Widget_signal_focus_in_event_info =
 };
 
 
-static gboolean Widget_signal_focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
+gboolean Widget_signal_focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventFocus* > SlotType;
@@ -1902,26 +1713,22 @@ static gboolean Widget_signal_focus_out_event_callback(GtkWidget* self, GdkEvent
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_focus_out_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
+gboolean Widget_signal_focus_out_event_notify_callback(GtkWidget* self, GdkEventFocus* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventFocus* > SlotType;
@@ -1929,26 +1736,22 @@ static gboolean Widget_signal_focus_out_event_notify_callback(GtkWidget* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_focus_out_event_info =
+const Glib::SignalProxyInfo Widget_signal_focus_out_event_info =
 {
   "focus_out_event",
   (GCallback) &Widget_signal_focus_out_event_callback,
@@ -1956,7 +1759,7 @@ static const Glib::SignalProxyInfo Widget_signal_focus_out_event_info =
 };
 
 
-static gboolean Widget_signal_map_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+gboolean Widget_signal_map_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventAny* > SlotType;
@@ -1964,26 +1767,22 @@ static gboolean Widget_signal_map_event_callback(GtkWidget* self, GdkEventAny* p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_map_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+gboolean Widget_signal_map_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventAny* > SlotType;
@@ -1991,26 +1790,22 @@ static gboolean Widget_signal_map_event_notify_callback(GtkWidget* self, GdkEven
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_map_event_info =
+const Glib::SignalProxyInfo Widget_signal_map_event_info =
 {
   "map_event",
   (GCallback) &Widget_signal_map_event_callback,
@@ -2018,7 +1813,7 @@ static const Glib::SignalProxyInfo Widget_signal_map_event_info =
 };
 
 
-static gboolean Widget_signal_unmap_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+gboolean Widget_signal_unmap_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventAny* > SlotType;
@@ -2026,26 +1821,22 @@ static gboolean Widget_signal_unmap_event_callback(GtkWidget* self, GdkEventAny*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_unmap_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+gboolean Widget_signal_unmap_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventAny* > SlotType;
@@ -2053,26 +1844,22 @@ static gboolean Widget_signal_unmap_event_notify_callback(GtkWidget* self, GdkEv
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_unmap_event_info =
+const Glib::SignalProxyInfo Widget_signal_unmap_event_info =
 {
   "unmap_event",
   (GCallback) &Widget_signal_unmap_event_callback,
@@ -2080,7 +1867,7 @@ static const Glib::SignalProxyInfo Widget_signal_unmap_event_info =
 };
 
 
-static gboolean Widget_signal_property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0,void* data)
+gboolean Widget_signal_property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventProperty* > SlotType;
@@ -2088,26 +1875,22 @@ static gboolean Widget_signal_property_notify_event_callback(GtkWidget* self, Gd
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_property_notify_event_notify_callback(GtkWidget* self, GdkEventProperty* p0, void* data)
+gboolean Widget_signal_property_notify_event_notify_callback(GtkWidget* self, GdkEventProperty* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventProperty* > SlotType;
@@ -2115,26 +1898,22 @@ static gboolean Widget_signal_property_notify_event_notify_callback(GtkWidget* s
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_property_notify_event_info =
+const Glib::SignalProxyInfo Widget_signal_property_notify_event_info =
 {
   "property_notify_event",
   (GCallback) &Widget_signal_property_notify_event_callback,
@@ -2142,7 +1921,7 @@ static const Glib::SignalProxyInfo Widget_signal_property_notify_event_info =
 };
 
 
-static gboolean Widget_signal_selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
+gboolean Widget_signal_selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventSelection* > SlotType;
@@ -2150,26 +1929,22 @@ static gboolean Widget_signal_selection_clear_event_callback(GtkWidget* self, Gd
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_selection_clear_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
+gboolean Widget_signal_selection_clear_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventSelection* > SlotType;
@@ -2177,26 +1952,22 @@ static gboolean Widget_signal_selection_clear_event_notify_callback(GtkWidget* s
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_selection_clear_event_info =
+const Glib::SignalProxyInfo Widget_signal_selection_clear_event_info =
 {
   "selection_clear_event",
   (GCallback) &Widget_signal_selection_clear_event_callback,
@@ -2204,7 +1975,7 @@ static const Glib::SignalProxyInfo Widget_signal_selection_clear_event_info =
 };
 
 
-static gboolean Widget_signal_selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
+gboolean Widget_signal_selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventSelection* > SlotType;
@@ -2212,26 +1983,22 @@ static gboolean Widget_signal_selection_request_event_callback(GtkWidget* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_selection_request_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
+gboolean Widget_signal_selection_request_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventSelection* > SlotType;
@@ -2239,26 +2006,22 @@ static gboolean Widget_signal_selection_request_event_notify_callback(GtkWidget*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_selection_request_event_info =
+const Glib::SignalProxyInfo Widget_signal_selection_request_event_info =
 {
   "selection_request_event",
   (GCallback) &Widget_signal_selection_request_event_callback,
@@ -2266,7 +2029,7 @@ static const Glib::SignalProxyInfo Widget_signal_selection_request_event_info =
 };
 
 
-static gboolean Widget_signal_selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
+gboolean Widget_signal_selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventSelection* > SlotType;
@@ -2274,26 +2037,22 @@ static gboolean Widget_signal_selection_notify_event_callback(GtkWidget* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_selection_notify_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
+gboolean Widget_signal_selection_notify_event_notify_callback(GtkWidget* self, GdkEventSelection* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventSelection* > SlotType;
@@ -2301,26 +2060,22 @@ static gboolean Widget_signal_selection_notify_event_notify_callback(GtkWidget*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_selection_notify_event_info =
+const Glib::SignalProxyInfo Widget_signal_selection_notify_event_info =
 {
   "selection_notify_event",
   (GCallback) &Widget_signal_selection_notify_event_callback,
@@ -2328,7 +2083,7 @@ static const Glib::SignalProxyInfo Widget_signal_selection_notify_event_info =
 };
 
 
-static gboolean Widget_signal_proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
+gboolean Widget_signal_proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventProximity* > SlotType;
@@ -2336,26 +2091,22 @@ static gboolean Widget_signal_proximity_in_event_callback(GtkWidget* self, GdkEv
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_proximity_in_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
+gboolean Widget_signal_proximity_in_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventProximity* > SlotType;
@@ -2363,26 +2114,22 @@ static gboolean Widget_signal_proximity_in_event_notify_callback(GtkWidget* self
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_proximity_in_event_info =
+const Glib::SignalProxyInfo Widget_signal_proximity_in_event_info =
 {
   "proximity_in_event",
   (GCallback) &Widget_signal_proximity_in_event_callback,
@@ -2390,7 +2137,7 @@ static const Glib::SignalProxyInfo Widget_signal_proximity_in_event_info =
 };
 
 
-static gboolean Widget_signal_proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
+gboolean Widget_signal_proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventProximity* > SlotType;
@@ -2398,26 +2145,22 @@ static gboolean Widget_signal_proximity_out_event_callback(GtkWidget* self, GdkE
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_proximity_out_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
+gboolean Widget_signal_proximity_out_event_notify_callback(GtkWidget* self, GdkEventProximity* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventProximity* > SlotType;
@@ -2425,26 +2168,22 @@ static gboolean Widget_signal_proximity_out_event_notify_callback(GtkWidget* sel
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_proximity_out_event_info =
+const Glib::SignalProxyInfo Widget_signal_proximity_out_event_info =
 {
   "proximity_out_event",
   (GCallback) &Widget_signal_proximity_out_event_callback,
@@ -2452,7 +2191,7 @@ static const Glib::SignalProxyInfo Widget_signal_proximity_out_event_info =
 };
 
 
-static gboolean Widget_signal_visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0,void* data)
+gboolean Widget_signal_visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventVisibility* > SlotType;
@@ -2460,26 +2199,22 @@ static gboolean Widget_signal_visibility_notify_event_callback(GtkWidget* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_visibility_notify_event_notify_callback(GtkWidget* self, GdkEventVisibility* p0, void* data)
+gboolean Widget_signal_visibility_notify_event_notify_callback(GtkWidget* self, GdkEventVisibility* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventVisibility* > SlotType;
@@ -2487,26 +2222,22 @@ static gboolean Widget_signal_visibility_notify_event_notify_callback(GtkWidget*
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_visibility_notify_event_info =
+const Glib::SignalProxyInfo Widget_signal_visibility_notify_event_info =
 {
   "visibility_notify_event",
   (GCallback) &Widget_signal_visibility_notify_event_callback,
@@ -2514,7 +2245,7 @@ static const Glib::SignalProxyInfo Widget_signal_visibility_notify_event_info =
 };
 
 
-static gboolean Widget_signal_client_event_callback(GtkWidget* self, GdkEventClient* p0,void* data)
+gboolean Widget_signal_client_event_callback(GtkWidget* self, GdkEventClient* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventClient* > SlotType;
@@ -2522,26 +2253,22 @@ static gboolean Widget_signal_client_event_callback(GtkWidget* self, GdkEventCli
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_client_event_notify_callback(GtkWidget* self, GdkEventClient* p0, void* data)
+gboolean Widget_signal_client_event_notify_callback(GtkWidget* self, GdkEventClient* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventClient* > SlotType;
@@ -2549,26 +2276,22 @@ static gboolean Widget_signal_client_event_notify_callback(GtkWidget* self, GdkE
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_client_event_info =
+const Glib::SignalProxyInfo Widget_signal_client_event_info =
 {
   "client_event",
   (GCallback) &Widget_signal_client_event_callback,
@@ -2576,7 +2299,7 @@ static const Glib::SignalProxyInfo Widget_signal_client_event_info =
 };
 
 
-static gboolean Widget_signal_no_expose_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
+gboolean Widget_signal_no_expose_event_callback(GtkWidget* self, GdkEventAny* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventAny* > SlotType;
@@ -2584,26 +2307,22 @@ static gboolean Widget_signal_no_expose_event_callback(GtkWidget* self, GdkEvent
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_no_expose_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
+gboolean Widget_signal_no_expose_event_notify_callback(GtkWidget* self, GdkEventAny* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventAny* > SlotType;
@@ -2611,26 +2330,22 @@ static gboolean Widget_signal_no_expose_event_notify_callback(GtkWidget* self, G
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_no_expose_event_info =
+const Glib::SignalProxyInfo Widget_signal_no_expose_event_info =
 {
   "no_expose_event",
   (GCallback) &Widget_signal_no_expose_event_callback,
@@ -2638,7 +2353,7 @@ static const Glib::SignalProxyInfo Widget_signal_no_expose_event_info =
 };
 
 
-static gboolean Widget_signal_window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0,void* data)
+gboolean Widget_signal_window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEventWindowState* > SlotType;
@@ -2646,26 +2361,22 @@ static gboolean Widget_signal_window_state_event_callback(GtkWidget* self, GdkEv
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_window_state_event_notify_callback(GtkWidget* self, GdkEventWindowState* p0, void* data)
+gboolean Widget_signal_window_state_event_notify_callback(GtkWidget* self, GdkEventWindowState* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEventWindowState* > SlotType;
@@ -2673,26 +2384,22 @@ static gboolean Widget_signal_window_state_event_notify_callback(GtkWidget* self
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_window_state_event_info =
+const Glib::SignalProxyInfo Widget_signal_window_state_event_info =
 {
   "window_state_event",
   (GCallback) &Widget_signal_window_state_event_callback,
@@ -2700,7 +2407,7 @@ static const Glib::SignalProxyInfo Widget_signal_window_state_event_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_selection_get_info =
+const Glib::SignalProxyInfo Widget_signal_selection_get_info =
 {
   "selection_get",
   (GCallback) &Widget_signal_selection_get_callback,
@@ -2708,7 +2415,7 @@ static const Glib::SignalProxyInfo Widget_signal_selection_get_info =
 };
 
 
-static void Widget_signal_selection_received_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,void* data)
+void Widget_signal_selection_received_callback(GtkWidget* self, GtkSelectionData* p0,guint p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const SelectionData&,guint > SlotType;
@@ -2716,24 +2423,20 @@ static void Widget_signal_selection_received_callback(GtkWidget* self, GtkSelect
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(SelectionData_WithoutOwnership(p0)
 , p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_selection_received_info =
+const Glib::SignalProxyInfo Widget_signal_selection_received_info =
 {
   "selection_received",
   (GCallback) &Widget_signal_selection_received_callback,
@@ -2741,7 +2444,7 @@ static const Glib::SignalProxyInfo Widget_signal_selection_received_info =
 };
 
 
-static void Widget_signal_drag_begin_callback(GtkWidget* self, GdkDragContext* p0,void* data)
+void Widget_signal_drag_begin_callback(GtkWidget* self, GdkDragContext* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
@@ -2749,24 +2452,20 @@ static void Widget_signal_drag_begin_callback(GtkWidget* self, GdkDragContext* p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_drag_begin_info =
+const Glib::SignalProxyInfo Widget_signal_drag_begin_info =
 {
   "drag_begin",
   (GCallback) &Widget_signal_drag_begin_callback,
@@ -2774,7 +2473,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_begin_info =
 };
 
 
-static void Widget_signal_drag_end_callback(GtkWidget* self, GdkDragContext* p0,void* data)
+void Widget_signal_drag_end_callback(GtkWidget* self, GdkDragContext* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
@@ -2782,24 +2481,20 @@ static void Widget_signal_drag_end_callback(GtkWidget* self, GdkDragContext* p0,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_drag_end_info =
+const Glib::SignalProxyInfo Widget_signal_drag_end_info =
 {
   "drag_end",
   (GCallback) &Widget_signal_drag_end_callback,
@@ -2807,7 +2502,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_end_info =
 };
 
 
-static const Glib::SignalProxyInfo Widget_signal_drag_data_get_info =
+const Glib::SignalProxyInfo Widget_signal_drag_data_get_info =
 {
   "drag_data_get",
   (GCallback) &Widget_signal_drag_data_get_callback,
@@ -2815,7 +2510,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_data_get_info =
 };
 
 
-static void Widget_signal_drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0,void* data)
+void Widget_signal_drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>& > SlotType;
@@ -2823,24 +2518,20 @@ static void Widget_signal_drag_data_delete_callback(GtkWidget* self, GdkDragCont
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_drag_data_delete_info =
+const Glib::SignalProxyInfo Widget_signal_drag_data_delete_info =
 {
   "drag_data_delete",
   (GCallback) &Widget_signal_drag_data_delete_callback,
@@ -2848,7 +2539,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_data_delete_info =
 };
 
 
-static void Widget_signal_drag_leave_callback(GtkWidget* self, GdkDragContext* p0,guint p1,void* data)
+void Widget_signal_drag_leave_callback(GtkWidget* self, GdkDragContext* p0,guint p1,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,guint > SlotType;
@@ -2856,24 +2547,20 @@ static void Widget_signal_drag_leave_callback(GtkWidget* self, GdkDragContext* p
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_drag_leave_info =
+const Glib::SignalProxyInfo Widget_signal_drag_leave_info =
 {
   "drag_leave",
   (GCallback) &Widget_signal_drag_leave_callback,
@@ -2881,7 +2568,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_leave_info =
 };
 
 
-static gboolean Widget_signal_drag_motion_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
+gboolean Widget_signal_drag_motion_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
@@ -2889,29 +2576,25 @@ static gboolean Widget_signal_drag_motion_callback(GtkWidget* self, GdkDragConte
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1
 , p2
 , p3));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_drag_motion_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
+gboolean Widget_signal_drag_motion_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
@@ -2919,29 +2602,25 @@ static gboolean Widget_signal_drag_motion_notify_callback(GtkWidget* self, GdkDr
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1
 , p2
 , p3);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_drag_motion_info =
+const Glib::SignalProxyInfo Widget_signal_drag_motion_info =
 {
   "drag_motion",
   (GCallback) &Widget_signal_drag_motion_callback,
@@ -2949,7 +2628,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_motion_info =
 };
 
 
-static gboolean Widget_signal_drag_drop_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
+gboolean Widget_signal_drag_drop_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
@@ -2957,29 +2636,25 @@ static gboolean Widget_signal_drag_drop_callback(GtkWidget* self, GdkDragContext
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1
 , p2
 , p3));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Widget_signal_drag_drop_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
+gboolean Widget_signal_drag_drop_notify_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,guint p3, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > SlotType;
@@ -2987,29 +2662,25 @@ static gboolean Widget_signal_drag_drop_notify_callback(GtkWidget* self, GdkDrag
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1
 , p2
 , p3);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_drag_drop_info =
+const Glib::SignalProxyInfo Widget_signal_drag_drop_info =
 {
   "drag_drop",
   (GCallback) &Widget_signal_drag_drop_callback,
@@ -3017,7 +2688,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_drop_info =
 };
 
 
-static void Widget_signal_drag_data_received_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,GtkSelectionData* p3,guint p4,guint p5,void* data)
+void Widget_signal_drag_data_received_callback(GtkWidget* self, GdkDragContext* p0,gint p1,gint p2,GtkSelectionData* p3,guint p4,guint p5,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > SlotType;
@@ -3025,27 +2696,23 @@ static void Widget_signal_drag_data_received_callback(GtkWidget* self, GdkDragCo
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1
 , p2
 , SelectionData_WithoutOwnership(p3)
 , p4, p5);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_drag_data_received_info =
+const Glib::SignalProxyInfo Widget_signal_drag_data_received_info =
 {
   "drag_data_received",
   (GCallback) &Widget_signal_drag_data_received_callback,
@@ -3053,9 +2720,7 @@ static const Glib::SignalProxyInfo Widget_signal_drag_data_received_info =
 };
 
 
-#ifdef GTKMM_ATKMM_ENABLED
-
-static AtkObject* Widget_signal_get_accessible_callback(GtkWidget* self, void* data)
+AtkObject* Widget_signal_get_accessible_callback(GtkWidget* self, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< Glib::RefPtr<Atk::Object> > SlotType;
@@ -3063,26 +2728,22 @@ static AtkObject* Widget_signal_get_accessible_callback(GtkWidget* self, void* d
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return Glib::unwrap((*static_cast<SlotType*>(slot))());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef AtkObject* RType;
   return RType();
 }
 
-static AtkObject* Widget_signal_get_accessible_notify_callback(GtkWidget* self,  void* data)
+AtkObject* Widget_signal_get_accessible_notify_callback(GtkWidget* self,  void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void > SlotType;
@@ -3090,36 +2751,30 @@ static AtkObject* Widget_signal_get_accessible_notify_callback(GtkWidget* self,
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef AtkObject* RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Widget_signal_get_accessible_info =
+const Glib::SignalProxyInfo Widget_signal_get_accessible_info =
 {
   "get_accessible",
   (GCallback) &Widget_signal_get_accessible_callback,
   (GCallback) &Widget_signal_get_accessible_notify_callback
 };
 
-#endif // GTKMM_ATKMM_ENABLED
-
 
-static void Widget_signal_screen_changed_callback(GtkWidget* self, GdkScreen* p0,void* data)
+void Widget_signal_screen_changed_callback(GtkWidget* self, GdkScreen* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,const Glib::RefPtr<Gdk::Screen>& > SlotType;
@@ -3127,39 +2782,26 @@ static void Widget_signal_screen_changed_callback(GtkWidget* self, GdkScreen* p0
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Widget_signal_screen_changed_info =
+const Glib::SignalProxyInfo Widget_signal_screen_changed_info =
 {
   "screen_changed",
   (GCallback) &Widget_signal_screen_changed_callback,
   (GCallback) &Widget_signal_screen_changed_callback
 };
 
-
-static const Glib::SignalProxyInfo Widget_signal_composited_changed_info =
-{
-  "composited_changed",
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
-  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
-};
-
-
 } // anonymous namespace
 
 // static
@@ -3212,10 +2854,7 @@ const Glib::Class& Widget_Class::init()
     register_derived_type(gtk_widget_get_type());
 
     // Add derived versions of interfaces, if the C type implements any interfaces:
-#ifdef GTKMM_ATKMM_ENABLED
   Atk::Implementor::add_interface(get_type());
-
-#endif // GTKMM_ATKMM_ENABLED
   }
 
   return *this;
@@ -3226,19 +2865,11 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED //We always need dispose_vfunc_callback
     reinterpret_cast<GObjectClass*>(klass)->dispose = &dispose_vfunc_callback;
-#ifdef GLIBMM_VFUNCS_ENABLED
     klass->dispatch_child_properties_changed = &dispatch_child_properties_changed_vfunc_callback;
   klass->show_all = &show_all_vfunc_callback;
   klass->hide_all = &hide_all_vfunc_callback;
-#ifdef GTKMM_ATKMM_ENABLED
   klass->get_accessible = &get_accessible_vfunc_callback;
-#endif // GTKMM_ATKMM_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   klass->show = &show_callback;
   klass->hide = &hide_callback;
   klass->map = &map_callback;
@@ -3293,16 +2924,12 @@ void Widget_Class::class_init_function(void* g_class, void* class_data)
   klass->drag_motion = &drag_motion_callback;
   klass->drag_drop = &drag_drop_callback;
   klass->drag_data_received = &drag_data_received_callback;
-#ifdef GTKMM_ATKMM_ENABLED
   klass->get_accessible = &get_accessible_callback;
-#endif // GTKMM_ATKMM_ENABLED
   klass->screen_changed = &screen_changed_callback;
     klass->hierarchy_changed = &hierarchy_changed_callback_custom;
       klass->parent_set = &parent_set_callback_custom;
-  #endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
+  }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Widget_Class::dispatch_child_properties_changed_vfunc_callback(GtkWidget* self, guint n_pspecs, GParamSpec** pspecs)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3315,19 +2942,15 @@ void Widget_Class::dispatch_child_properties_changed_vfunc_callback(GtkWidget* s
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->dispatch_child_properties_changed_vfunc(n_pspecs, pspecs);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3340,6 +2963,7 @@ void Widget_Class::dispatch_child_properties_changed_vfunc_callback(GtkWidget* s
       (*base->dispatch_child_properties_changed)(self, n_pspecs, pspecs);
   }
 }
+
 void Widget_Class::show_all_vfunc_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3352,19 +2976,15 @@ void Widget_Class::show_all_vfunc_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->show_all_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3377,6 +2997,7 @@ void Widget_Class::show_all_vfunc_callback(GtkWidget* self)
       (*base->show_all)(self);
   }
 }
+
 void Widget_Class::hide_all_vfunc_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3389,19 +3010,15 @@ void Widget_Class::hide_all_vfunc_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->hide_all_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3414,7 +3031,7 @@ void Widget_Class::hide_all_vfunc_callback(GtkWidget* self)
       (*base->hide_all)(self);
   }
 }
-#ifdef GTKMM_ATKMM_ENABLED
+
 AtkObject* Widget_Class::get_accessible_vfunc_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3427,19 +3044,15 @@ AtkObject* Widget_Class::get_accessible_vfunc_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->get_accessible_vfunc());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3455,10 +3068,8 @@ AtkObject* Widget_Class::get_accessible_vfunc_callback(GtkWidget* self)
   typedef AtkObject* RType;
   return RType();
 }
-#endif // GTKMM_ATKMM_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
+
 void Widget_Class::show_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3471,19 +3082,15 @@ void Widget_Class::show_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_show();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3496,6 +3103,7 @@ void Widget_Class::show_callback(GtkWidget* self)
       (*base->show)(self);
   }
 }
+
 void Widget_Class::hide_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3508,19 +3116,15 @@ void Widget_Class::hide_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_hide();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3533,6 +3137,7 @@ void Widget_Class::hide_callback(GtkWidget* self)
       (*base->hide)(self);
   }
 }
+
 void Widget_Class::map_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3545,19 +3150,15 @@ void Widget_Class::map_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_map();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3570,6 +3171,7 @@ void Widget_Class::map_callback(GtkWidget* self)
       (*base->map)(self);
   }
 }
+
 void Widget_Class::unmap_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3582,19 +3184,15 @@ void Widget_Class::unmap_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_unmap();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3607,6 +3205,7 @@ void Widget_Class::unmap_callback(GtkWidget* self)
       (*base->unmap)(self);
   }
 }
+
 void Widget_Class::realize_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3619,19 +3218,15 @@ void Widget_Class::realize_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_realize();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3644,6 +3239,7 @@ void Widget_Class::realize_callback(GtkWidget* self)
       (*base->realize)(self);
   }
 }
+
 void Widget_Class::unrealize_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3656,19 +3252,15 @@ void Widget_Class::unrealize_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_unrealize();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3681,6 +3273,7 @@ void Widget_Class::unrealize_callback(GtkWidget* self)
       (*base->unrealize)(self);
   }
 }
+
 void Widget_Class::size_request_callback(GtkWidget* self, GtkRequisition* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3693,20 +3286,16 @@ void Widget_Class::size_request_callback(GtkWidget* self, GtkRequisition* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_size_request((Requisition*)(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3719,6 +3308,7 @@ void Widget_Class::size_request_callback(GtkWidget* self, GtkRequisition* p0)
       (*base->size_request)(self, p0);
   }
 }
+
 void Widget_Class::size_allocate_callback(GtkWidget* self, GtkAllocation* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3731,20 +3321,16 @@ void Widget_Class::size_allocate_callback(GtkWidget* self, GtkAllocation* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_size_allocate((Allocation&)(Glib::wrap(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3757,6 +3343,7 @@ void Widget_Class::size_allocate_callback(GtkWidget* self, GtkAllocation* p0)
       (*base->size_allocate)(self, p0);
   }
 }
+
 void Widget_Class::state_changed_callback(GtkWidget* self, GtkStateType p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3769,20 +3356,16 @@ void Widget_Class::state_changed_callback(GtkWidget* self, GtkStateType p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_state_changed(((Gtk::StateType)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3795,6 +3378,7 @@ void Widget_Class::state_changed_callback(GtkWidget* self, GtkStateType p0)
       (*base->state_changed)(self, p0);
   }
 }
+
 void Widget_Class::parent_set_callback(GtkWidget* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3807,20 +3391,16 @@ void Widget_Class::parent_set_callback(GtkWidget* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_parent_changed(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3833,6 +3413,7 @@ void Widget_Class::parent_set_callback(GtkWidget* self, GtkWidget* p0)
       (*base->parent_set)(self, p0);
   }
 }
+
 void Widget_Class::hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3845,20 +3426,16 @@ void Widget_Class::hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_hierarchy_changed(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3871,6 +3448,7 @@ void Widget_Class::hierarchy_changed_callback(GtkWidget* self, GtkWidget* p0)
       (*base->hierarchy_changed)(self, p0);
   }
 }
+
 void Widget_Class::style_set_callback(GtkWidget* self, GtkStyle* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3883,20 +3461,16 @@ void Widget_Class::style_set_callback(GtkWidget* self, GtkStyle* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_style_changed(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3909,6 +3483,7 @@ void Widget_Class::style_set_callback(GtkWidget* self, GtkStyle* p0)
       (*base->style_set)(self, p0);
   }
 }
+
 void Widget_Class::direction_changed_callback(GtkWidget* self, GtkTextDirection p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3921,20 +3496,16 @@ void Widget_Class::direction_changed_callback(GtkWidget* self, GtkTextDirection
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_direction_changed(((TextDirection)(p0))
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3947,6 +3518,7 @@ void Widget_Class::direction_changed_callback(GtkWidget* self, GtkTextDirection
       (*base->direction_changed)(self, p0);
   }
 }
+
 void Widget_Class::grab_notify_callback(GtkWidget* self, gboolean p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3959,20 +3531,16 @@ void Widget_Class::grab_notify_callback(GtkWidget* self, gboolean p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_grab_notify(p0
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -3985,6 +3553,7 @@ void Widget_Class::grab_notify_callback(GtkWidget* self, gboolean p0)
       (*base->grab_notify)(self, p0);
   }
 }
+
 void Widget_Class::child_notify_callback(GtkWidget* self, GParamSpec* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -3997,19 +3566,15 @@ void Widget_Class::child_notify_callback(GtkWidget* self, GParamSpec* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_child_notify(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4022,6 +3587,7 @@ void Widget_Class::child_notify_callback(GtkWidget* self, GParamSpec* p0)
       (*base->child_notify)(self, p0);
   }
 }
+
 gboolean Widget_Class::mnemonic_activate_callback(GtkWidget* self, gboolean p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4034,20 +3600,16 @@ gboolean Widget_Class::mnemonic_activate_callback(GtkWidget* self, gboolean p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_mnemonic_activate(p0
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4063,6 +3625,7 @@ gboolean Widget_Class::mnemonic_activate_callback(GtkWidget* self, gboolean p0)
   typedef gboolean RType;
   return RType();
 }
+
 void Widget_Class::grab_focus_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4075,19 +3638,15 @@ void Widget_Class::grab_focus_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_grab_focus();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4100,6 +3659,7 @@ void Widget_Class::grab_focus_callback(GtkWidget* self)
       (*base->grab_focus)(self);
   }
 }
+
 gboolean Widget_Class::focus_callback(GtkWidget* self, GtkDirectionType p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4112,20 +3672,16 @@ gboolean Widget_Class::focus_callback(GtkWidget* self, GtkDirectionType p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_focus(((DirectionType)(p0))
 ));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4141,6 +3697,7 @@ gboolean Widget_Class::focus_callback(GtkWidget* self, GtkDirectionType p0)
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::event_callback(GtkWidget* self, GdkEvent* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4153,19 +3710,15 @@ gboolean Widget_Class::event_callback(GtkWidget* self, GdkEvent* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4181,6 +3734,7 @@ gboolean Widget_Class::event_callback(GtkWidget* self, GdkEvent* p0)
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::button_press_event_callback(GtkWidget* self, GdkEventButton* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4193,19 +3747,15 @@ gboolean Widget_Class::button_press_event_callback(GtkWidget* self, GdkEventButt
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_button_press_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4221,6 +3771,7 @@ gboolean Widget_Class::button_press_event_callback(GtkWidget* self, GdkEventButt
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::button_release_event_callback(GtkWidget* self, GdkEventButton* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4233,19 +3784,15 @@ gboolean Widget_Class::button_release_event_callback(GtkWidget* self, GdkEventBu
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_button_release_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4261,6 +3808,7 @@ gboolean Widget_Class::button_release_event_callback(GtkWidget* self, GdkEventBu
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::scroll_event_callback(GtkWidget* self, GdkEventScroll* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4273,19 +3821,15 @@ gboolean Widget_Class::scroll_event_callback(GtkWidget* self, GdkEventScroll* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_scroll_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4301,6 +3845,7 @@ gboolean Widget_Class::scroll_event_callback(GtkWidget* self, GdkEventScroll* p0
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::motion_notify_event_callback(GtkWidget* self, GdkEventMotion* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4313,19 +3858,15 @@ gboolean Widget_Class::motion_notify_event_callback(GtkWidget* self, GdkEventMot
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_motion_notify_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4341,6 +3882,7 @@ gboolean Widget_Class::motion_notify_event_callback(GtkWidget* self, GdkEventMot
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::delete_event_callback(GtkWidget* self, GdkEventAny* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4353,19 +3895,15 @@ gboolean Widget_Class::delete_event_callback(GtkWidget* self, GdkEventAny* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_delete_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4381,6 +3919,7 @@ gboolean Widget_Class::delete_event_callback(GtkWidget* self, GdkEventAny* p0)
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::expose_event_callback(GtkWidget* self, GdkEventExpose* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4393,19 +3932,15 @@ gboolean Widget_Class::expose_event_callback(GtkWidget* self, GdkEventExpose* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_expose_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4421,6 +3956,7 @@ gboolean Widget_Class::expose_event_callback(GtkWidget* self, GdkEventExpose* p0
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::key_press_event_callback(GtkWidget* self, GdkEventKey* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4433,19 +3969,15 @@ gboolean Widget_Class::key_press_event_callback(GtkWidget* self, GdkEventKey* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_key_press_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4461,6 +3993,7 @@ gboolean Widget_Class::key_press_event_callback(GtkWidget* self, GdkEventKey* p0
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::key_release_event_callback(GtkWidget* self, GdkEventKey* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4473,19 +4006,15 @@ gboolean Widget_Class::key_release_event_callback(GtkWidget* self, GdkEventKey*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_key_release_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4501,6 +4030,7 @@ gboolean Widget_Class::key_release_event_callback(GtkWidget* self, GdkEventKey*
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::enter_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4513,19 +4043,15 @@ gboolean Widget_Class::enter_notify_event_callback(GtkWidget* self, GdkEventCros
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_enter_notify_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4541,6 +4067,7 @@ gboolean Widget_Class::enter_notify_event_callback(GtkWidget* self, GdkEventCros
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::leave_notify_event_callback(GtkWidget* self, GdkEventCrossing* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4553,19 +4080,15 @@ gboolean Widget_Class::leave_notify_event_callback(GtkWidget* self, GdkEventCros
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_leave_notify_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4581,6 +4104,7 @@ gboolean Widget_Class::leave_notify_event_callback(GtkWidget* self, GdkEventCros
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::configure_event_callback(GtkWidget* self, GdkEventConfigure* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4593,19 +4117,15 @@ gboolean Widget_Class::configure_event_callback(GtkWidget* self, GdkEventConfigu
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_configure_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4621,6 +4141,7 @@ gboolean Widget_Class::configure_event_callback(GtkWidget* self, GdkEventConfigu
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::focus_in_event_callback(GtkWidget* self, GdkEventFocus* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4633,19 +4154,15 @@ gboolean Widget_Class::focus_in_event_callback(GtkWidget* self, GdkEventFocus* p
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_focus_in_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4661,6 +4178,7 @@ gboolean Widget_Class::focus_in_event_callback(GtkWidget* self, GdkEventFocus* p
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::focus_out_event_callback(GtkWidget* self, GdkEventFocus* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4673,19 +4191,15 @@ gboolean Widget_Class::focus_out_event_callback(GtkWidget* self, GdkEventFocus*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_focus_out_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4701,6 +4215,7 @@ gboolean Widget_Class::focus_out_event_callback(GtkWidget* self, GdkEventFocus*
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::map_event_callback(GtkWidget* self, GdkEventAny* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4713,19 +4228,15 @@ gboolean Widget_Class::map_event_callback(GtkWidget* self, GdkEventAny* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_map_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4741,6 +4252,7 @@ gboolean Widget_Class::map_event_callback(GtkWidget* self, GdkEventAny* p0)
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::unmap_event_callback(GtkWidget* self, GdkEventAny* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4753,19 +4265,15 @@ gboolean Widget_Class::unmap_event_callback(GtkWidget* self, GdkEventAny* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_unmap_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4781,6 +4289,7 @@ gboolean Widget_Class::unmap_event_callback(GtkWidget* self, GdkEventAny* p0)
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::property_notify_event_callback(GtkWidget* self, GdkEventProperty* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4793,19 +4302,15 @@ gboolean Widget_Class::property_notify_event_callback(GtkWidget* self, GdkEventP
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_property_notify_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4821,6 +4326,7 @@ gboolean Widget_Class::property_notify_event_callback(GtkWidget* self, GdkEventP
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::selection_clear_event_callback(GtkWidget* self, GdkEventSelection* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4833,19 +4339,15 @@ gboolean Widget_Class::selection_clear_event_callback(GtkWidget* self, GdkEventS
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_selection_clear_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4861,6 +4363,7 @@ gboolean Widget_Class::selection_clear_event_callback(GtkWidget* self, GdkEventS
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::selection_request_event_callback(GtkWidget* self, GdkEventSelection* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4873,19 +4376,15 @@ gboolean Widget_Class::selection_request_event_callback(GtkWidget* self, GdkEven
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_selection_request_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4901,6 +4400,7 @@ gboolean Widget_Class::selection_request_event_callback(GtkWidget* self, GdkEven
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::selection_notify_event_callback(GtkWidget* self, GdkEventSelection* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4913,19 +4413,15 @@ gboolean Widget_Class::selection_notify_event_callback(GtkWidget* self, GdkEvent
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_selection_notify_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4941,6 +4437,7 @@ gboolean Widget_Class::selection_notify_event_callback(GtkWidget* self, GdkEvent
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::proximity_in_event_callback(GtkWidget* self, GdkEventProximity* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4953,19 +4450,15 @@ gboolean Widget_Class::proximity_in_event_callback(GtkWidget* self, GdkEventProx
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_proximity_in_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -4981,6 +4474,7 @@ gboolean Widget_Class::proximity_in_event_callback(GtkWidget* self, GdkEventProx
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::proximity_out_event_callback(GtkWidget* self, GdkEventProximity* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -4993,19 +4487,15 @@ gboolean Widget_Class::proximity_out_event_callback(GtkWidget* self, GdkEventPro
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_proximity_out_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5021,6 +4511,7 @@ gboolean Widget_Class::proximity_out_event_callback(GtkWidget* self, GdkEventPro
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::visibility_notify_event_callback(GtkWidget* self, GdkEventVisibility* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5033,19 +4524,15 @@ gboolean Widget_Class::visibility_notify_event_callback(GtkWidget* self, GdkEven
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_visibility_notify_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5061,6 +4548,7 @@ gboolean Widget_Class::visibility_notify_event_callback(GtkWidget* self, GdkEven
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::client_event_callback(GtkWidget* self, GdkEventClient* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5073,19 +4561,15 @@ gboolean Widget_Class::client_event_callback(GtkWidget* self, GdkEventClient* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_client_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5101,6 +4585,7 @@ gboolean Widget_Class::client_event_callback(GtkWidget* self, GdkEventClient* p0
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::no_expose_event_callback(GtkWidget* self, GdkEventAny* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5113,19 +4598,15 @@ gboolean Widget_Class::no_expose_event_callback(GtkWidget* self, GdkEventAny* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_no_expose_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5141,6 +4622,7 @@ gboolean Widget_Class::no_expose_event_callback(GtkWidget* self, GdkEventAny* p0
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::window_state_event_callback(GtkWidget* self, GdkEventWindowState* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5153,19 +4635,15 @@ gboolean Widget_Class::window_state_event_callback(GtkWidget* self, GdkEventWind
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_window_state_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5181,6 +4659,7 @@ gboolean Widget_Class::window_state_event_callback(GtkWidget* self, GdkEventWind
   typedef gboolean RType;
   return RType();
 }
+
 void Widget_Class::selection_received_callback(GtkWidget* self, GtkSelectionData* p0, guint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5193,20 +4672,16 @@ void Widget_Class::selection_received_callback(GtkWidget* self, GtkSelectionData
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_selection_received(SelectionData_WithoutOwnership(p0)
 , p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5219,6 +4694,7 @@ void Widget_Class::selection_received_callback(GtkWidget* self, GtkSelectionData
       (*base->selection_received)(self, p0, p1);
   }
 }
+
 void Widget_Class::drag_begin_callback(GtkWidget* self, GdkDragContext* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5231,20 +4707,16 @@ void Widget_Class::drag_begin_callback(GtkWidget* self, GdkDragContext* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_drag_begin(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5257,6 +4729,7 @@ void Widget_Class::drag_begin_callback(GtkWidget* self, GdkDragContext* p0)
       (*base->drag_begin)(self, p0);
   }
 }
+
 void Widget_Class::drag_end_callback(GtkWidget* self, GdkDragContext* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5269,20 +4742,16 @@ void Widget_Class::drag_end_callback(GtkWidget* self, GdkDragContext* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_drag_end(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5295,6 +4764,7 @@ void Widget_Class::drag_end_callback(GtkWidget* self, GdkDragContext* p0)
       (*base->drag_end)(self, p0);
   }
 }
+
 void Widget_Class::drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5307,20 +4777,16 @@ void Widget_Class::drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_drag_data_delete(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5333,6 +4799,7 @@ void Widget_Class::drag_data_delete_callback(GtkWidget* self, GdkDragContext* p0
       (*base->drag_data_delete)(self, p0);
   }
 }
+
 void Widget_Class::drag_leave_callback(GtkWidget* self, GdkDragContext* p0, guint p1)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5345,20 +4812,16 @@ void Widget_Class::drag_leave_callback(GtkWidget* self, GdkDragContext* p0, guin
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_drag_leave(Glib::wrap(p0, true)
 , p1);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5371,6 +4834,7 @@ void Widget_Class::drag_leave_callback(GtkWidget* self, GdkDragContext* p0, guin
       (*base->drag_leave)(self, p0, p1);
   }
 }
+
 gboolean Widget_Class::drag_motion_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5383,22 +4847,18 @@ gboolean Widget_Class::drag_motion_callback(GtkWidget* self, GdkDragContext* p0,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_drag_motion(Glib::wrap(p0, true)
 , p1
 , p2
 , p3));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5414,6 +4874,7 @@ gboolean Widget_Class::drag_motion_callback(GtkWidget* self, GdkDragContext* p0,
   typedef gboolean RType;
   return RType();
 }
+
 gboolean Widget_Class::drag_drop_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, guint p3)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5426,22 +4887,18 @@ gboolean Widget_Class::drag_drop_callback(GtkWidget* self, GdkDragContext* p0, g
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_drag_drop(Glib::wrap(p0, true)
 , p1
 , p2
 , p3));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5457,6 +4914,7 @@ gboolean Widget_Class::drag_drop_callback(GtkWidget* self, GdkDragContext* p0, g
   typedef gboolean RType;
   return RType();
 }
+
 void Widget_Class::drag_data_received_callback(GtkWidget* self, GdkDragContext* p0, gint p1, gint p2, GtkSelectionData* p3, guint p4, guint p5)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5469,23 +4927,19 @@ void Widget_Class::drag_data_received_callback(GtkWidget* self, GdkDragContext*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_drag_data_received(Glib::wrap(p0, true)
 , p1
 , p2
 , SelectionData_WithoutOwnership(p3)
 , p4, p5);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5498,7 +4952,7 @@ void Widget_Class::drag_data_received_callback(GtkWidget* self, GdkDragContext*
       (*base->drag_data_received)(self, p0, p1, p2, p3, p4, p5);
   }
 }
-#ifdef GTKMM_ATKMM_ENABLED
+
 AtkObject* Widget_Class::get_accessible_callback(GtkWidget* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5511,19 +4965,15 @@ AtkObject* Widget_Class::get_accessible_callback(GtkWidget* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return Glib::unwrap(obj->on_get_accessible());
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5539,7 +4989,7 @@ AtkObject* Widget_Class::get_accessible_callback(GtkWidget* self)
   typedef AtkObject* RType;
   return RType();
 }
-#endif // GTKMM_ATKMM_ENABLED
+
 void Widget_Class::screen_changed_callback(GtkWidget* self, GdkScreen* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -5552,20 +5002,16 @@ void Widget_Class::screen_changed_callback(GtkWidget* self, GdkScreen* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_screen_changed(Glib::wrap(p0, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -5578,7 +5024,6 @@ void Widget_Class::screen_changed_callback(GtkWidget* self, GdkScreen* p0)
       (*base->screen_changed)(self, p0);
   }
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Widget_Class::wrap_new(GObject* o)
@@ -5622,61 +5067,57 @@ bool Widget::set_scroll_adjustments(Adjustment& hadjustment, Adjustment& vadjust
 
 void Widget::show()
 {
-gtk_widget_show(gobj()); 
+  gtk_widget_show(gobj());
 }
 
 void Widget::show_now()
 {
-gtk_widget_show_now(gobj()); 
+  gtk_widget_show_now(gobj());
 }
 
 void Widget::hide()
 {
-gtk_widget_hide(gobj()); 
+  gtk_widget_hide(gobj());
 }
 
 void Widget::show_all()
 {
-gtk_widget_show_all(gobj()); 
+  gtk_widget_show_all(gobj());
 }
 
 void Widget::hide_all()
 {
-gtk_widget_hide_all(gobj()); 
+  gtk_widget_hide_all(gobj());
 }
 
 void Widget::queue_draw()
 {
-gtk_widget_queue_draw(gobj()); 
+  gtk_widget_queue_draw(gobj());
 }
 
 void Widget::queue_draw_area(int x, int y, int width, int height)
 {
-gtk_widget_queue_draw_area(gobj(), x, y, width, height); 
+  gtk_widget_queue_draw_area(gobj(), x, y, width, height);
 }
 
 void Widget::queue_resize()
 {
-gtk_widget_queue_resize(gobj()); 
+  gtk_widget_queue_resize(gobj());
 }
 
-#ifndef GTKMM_DISABLE_DEPRECATED
-
 void Widget::size_request(const Requisition& requisition)
 {
-gtk_widget_size_request(gobj(), (GtkRequisition*)(&requisition)); 
+  gtk_widget_size_request(gobj(), (GtkRequisition*)(&requisition));
 }
 
-#endif // GTKMM_DISABLE_DEPRECATED
-
 void Widget::size_allocate(const Allocation& allocation)
 {
-gtk_widget_size_allocate(gobj(), (GtkAllocation*)(allocation.gobj())); 
+  gtk_widget_size_allocate(gobj(), (GtkAllocation*)(allocation.gobj()));
 }
 
 void Widget::add_accelerator(const Glib::ustring& accel_signal, const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods, AccelFlags accel_flags)
 {
-gtk_widget_add_accelerator(gobj(), accel_signal.c_str(), Glib::unwrap(accel_group), accel_key, ((GdkModifierType)(accel_mods)), ((GtkAccelFlags)(accel_flags))); 
+  gtk_widget_add_accelerator(gobj(), accel_signal.c_str(), Glib::unwrap(accel_group), accel_key, ((GdkModifierType)(accel_mods)), ((GtkAccelFlags)(accel_flags)));
 }
 
 bool Widget::remove_accelerator(const Glib::RefPtr<AccelGroup>& accel_group, guint accel_key, Gdk::ModifierType accel_mods)
@@ -5686,7 +5127,7 @@ bool Widget::remove_accelerator(const Glib::RefPtr<AccelGroup>& accel_group, gui
 
 void Widget::set_accel_path(const Glib::ustring& accel_path, const Glib::RefPtr<AccelGroup>& accel_group)
 {
-gtk_widget_set_accel_path(gobj(), accel_path.c_str(), Glib::unwrap(accel_group)); 
+  gtk_widget_set_accel_path(gobj(), accel_path.c_str(), Glib::unwrap(accel_group));
 }
 
 bool Widget::mnemonic_activate(bool group_cycling)
@@ -5711,7 +5152,7 @@ bool Widget::activate()
 
 void Widget::reparent(Widget & new_parent)
 {
-gtk_widget_reparent(gobj(), (new_parent).gobj()); 
+  gtk_widget_reparent(gobj(), (new_parent).gobj());
 }
 
 bool Widget::intersect(const Gdk::Rectangle& area, Gdk::Rectangle& intersection) const
@@ -5726,17 +5167,17 @@ Gdk::Region Widget::region_intersect(const Gdk::Region& region) const
 
 void Widget::freeze_child_notify()
 {
-gtk_widget_freeze_child_notify(gobj()); 
+  gtk_widget_freeze_child_notify(gobj());
 }
 
 void Widget::child_notify(const Glib::ustring& child_property)
 {
-gtk_widget_child_notify(gobj(), child_property.c_str()); 
+  gtk_widget_child_notify(gobj(), child_property.c_str());
 }
 
 void Widget::thaw_child_notify()
 {
-gtk_widget_thaw_child_notify(gobj()); 
+  gtk_widget_thaw_child_notify(gobj());
 }
 
 bool Widget::is_focus() const
@@ -5746,17 +5187,17 @@ bool Widget::is_focus() const
 
 void Widget::grab_focus()
 {
-gtk_widget_grab_focus(gobj()); 
+  gtk_widget_grab_focus(gobj());
 }
 
 void Widget::grab_default()
 {
-gtk_widget_grab_default(gobj()); 
+  gtk_widget_grab_default(gobj());
 }
 
 void Widget::set_name(const Glib::ustring& name)
 {
-gtk_widget_set_name(gobj(), name.c_str()); 
+  gtk_widget_set_name(gobj(), name.c_str());
 }
 
 Glib::ustring Widget::get_name() const
@@ -5766,32 +5207,32 @@ Glib::ustring Widget::get_name() const
 
 void Widget::set_state(Gtk::StateType state)
 {
-gtk_widget_set_state(gobj(), ((GtkStateType)(state))); 
+  gtk_widget_set_state(gobj(), ((GtkStateType)(state)));
 }
 
 void Widget::set_sensitive(bool sensitive)
 {
-gtk_widget_set_sensitive(gobj(), static_cast<int>(sensitive)); 
+  gtk_widget_set_sensitive(gobj(), static_cast<int>(sensitive));
 }
 
 void Widget::set_app_paintable(bool app_paintable)
 {
-gtk_widget_set_app_paintable(gobj(), static_cast<int>(app_paintable)); 
+  gtk_widget_set_app_paintable(gobj(), static_cast<int>(app_paintable));
 }
 
 void Widget::set_double_buffered(bool double_buffered)
 {
-gtk_widget_set_double_buffered(gobj(), static_cast<int>(double_buffered)); 
+  gtk_widget_set_double_buffered(gobj(), static_cast<int>(double_buffered));
 }
 
 void Widget::set_redraw_on_allocate(bool redraw_on_allocate)
 {
-gtk_widget_set_redraw_on_allocate(gobj(), static_cast<int>(redraw_on_allocate)); 
+  gtk_widget_set_redraw_on_allocate(gobj(), static_cast<int>(redraw_on_allocate));
 }
 
 void Widget::set_child_visible(bool is_visible)
 {
-gtk_widget_set_child_visible(gobj(), static_cast<int>(is_visible)); 
+  gtk_widget_set_child_visible(gobj(), static_cast<int>(is_visible));
 }
 
 bool Widget::get_child_visible() const
@@ -5806,27 +5247,32 @@ Container* Widget::get_parent()
 
 const Container* Widget::get_parent() const
 {
-  return const_cast<Widget*>(this)->get_parent();
+  return Glib::wrap((GtkContainer*)(gtk_widget_get_parent(const_cast<GtkWidget*>(gobj()))));
 }
 
 Glib::RefPtr<Gdk::Window> Widget::get_parent_window()
 {
 
   Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_parent_window(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Window> Widget::get_parent_window() const
 {
-  return const_cast<Widget*>(this)->get_parent_window();
+
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_parent_window(const_cast<GtkWidget*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Widget::set_parent_window(const Glib::RefPtr<const Gdk::Window>& parent_window)
 {
-gtk_widget_set_parent_window(gobj(), const_cast<GdkWindow*>(Glib::unwrap<Gdk::Window>(parent_window))); 
+  gtk_widget_set_parent_window(gobj(), const_cast<GdkWindow*>(Glib::unwrap<Gdk::Window>(parent_window)));
 }
 
 bool Widget::child_focus(DirectionType direction)
@@ -5836,27 +5282,27 @@ bool Widget::child_focus(DirectionType direction)
 
 void Widget::set_size_request(int width, int height)
 {
-gtk_widget_set_size_request(gobj(), width, height); 
+  gtk_widget_set_size_request(gobj(), width, height);
 }
 
 void Widget::get_size_request(int& width, int& height) const
 {
-gtk_widget_get_size_request(const_cast<GtkWidget*>(gobj()), &width, &height); 
+  gtk_widget_get_size_request(const_cast<GtkWidget*>(gobj()), &width, &height);
 }
 
 void Widget::set_events(Gdk::EventMask events)
 {
-gtk_widget_set_events(gobj(), events); 
+  gtk_widget_set_events(gobj(), events);
 }
 
 void Widget::add_events(Gdk::EventMask events)
 {
-gtk_widget_add_events(gobj(), events); 
+  gtk_widget_add_events(gobj(), events);
 }
 
 void Widget::set_extension_events(Gdk::ExtensionMode mode)
 {
-gtk_widget_set_extension_events(gobj(), ((GdkExtensionMode)(mode))); 
+  gtk_widget_set_extension_events(gobj(), ((GdkExtensionMode)(mode)));
 }
 
 Gdk::ExtensionMode Widget::get_extension_events() const
@@ -5871,7 +5317,7 @@ Container* Widget::get_toplevel()
 
 const Container* Widget::get_toplevel() const
 {
-  return const_cast<Widget*>(this)->get_toplevel();
+  return Glib::wrap((GtkContainer*)(gtk_widget_get_toplevel(const_cast<GtkWidget*>(gobj()))));
 }
 
 Widget* Widget::get_ancestor(GType widget_type)
@@ -5881,42 +5327,47 @@ Widget* Widget::get_ancestor(GType widget_type)
 
 const Widget* Widget::get_ancestor(GType widget_type) const
 {
-  return const_cast<Widget*>(this)->get_ancestor(widget_type);
+  return Glib::wrap(gtk_widget_get_ancestor(const_cast<GtkWidget*>(gobj()), widget_type));
 }
 
 Glib::RefPtr<Gdk::Colormap> Widget::get_colormap()
 {
 
   Glib::RefPtr<Gdk::Colormap> retvalue = Glib::wrap(gtk_widget_get_colormap(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Gdk::Visual> Widget::get_visual()
 {
 
   Glib::RefPtr<Gdk::Visual> retvalue = Glib::wrap(gtk_widget_get_visual(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Gdk::Screen> Widget::get_screen()
 {
 
   Glib::RefPtr<Gdk::Screen> retvalue = Glib::wrap(gtk_widget_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Screen> Widget::get_screen() const
 {
-  return const_cast<Widget*>(this)->get_screen();
+
+  Glib::RefPtr<const Gdk::Screen> retvalue = Glib::wrap(gtk_widget_get_screen(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 bool Widget::has_screen() const
@@ -5928,73 +5379,85 @@ Glib::RefPtr<Gdk::Display> Widget::get_display()
 {
 
   Glib::RefPtr<Gdk::Display> retvalue = Glib::wrap(gtk_widget_get_display(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Display> Widget::get_display() const
 {
-  return const_cast<Widget*>(this)->get_display();
+
+  Glib::RefPtr<const Gdk::Display> retvalue = Glib::wrap(gtk_widget_get_display(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Gdk::Window> Widget::get_root_window()
 {
 
   Glib::RefPtr<Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_root_window(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Window> Widget::get_root_window() const
 {
-  return const_cast<Widget*>(this)->get_root_window();
+
+  Glib::RefPtr<const Gdk::Window> retvalue = Glib::wrap((GdkWindowObject*)(gtk_widget_get_root_window(const_cast<GtkWidget*>(gobj()))));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 Glib::RefPtr<Settings> Widget::get_settings()
 {
 
   Glib::RefPtr<Settings> retvalue = Glib::wrap(gtk_widget_get_settings(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Clipboard> Widget::get_clipboard(const Glib::ustring& selection)
 {
 
   Glib::RefPtr<Clipboard> retvalue = Glib::wrap(gtk_widget_get_clipboard(gobj(), Gdk::AtomString::to_c_type(selection)));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Clipboard> Widget::get_clipboard(const Glib::ustring& selection) const
 {
-  return const_cast<Widget*>(this)->get_clipboard(selection);
+
+  Glib::RefPtr<const Clipboard> retvalue = Glib::wrap(gtk_widget_get_clipboard(const_cast<GtkWidget*>(gobj()), Gdk::AtomString::to_c_type(selection)));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
-#ifdef GTKMM_ATKMM_ENABLED
 Glib::RefPtr<Atk::Object> Widget::get_accessible()
 {
 
   Glib::RefPtr<Atk::Object> retvalue = Glib::wrap(gtk_widget_get_accessible(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
-
-#endif // GTKMM_ATKMM_ENABLED
 void Widget::set_colormap(const Glib::RefPtr<const Gdk::Colormap> & colormap)
 {
-gtk_widget_set_colormap(gobj(), const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap))); 
+  gtk_widget_set_colormap(gobj(), const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap)));
 }
 
 Gdk::EventMask Widget::get_events() const
@@ -6004,7 +5467,7 @@ Gdk::EventMask Widget::get_events() const
 
 void Widget::get_pointer(int & x, int & y) const
 {
-gtk_widget_get_pointer(const_cast<GtkWidget*>(gobj()), &x, &y); 
+  gtk_widget_get_pointer(const_cast<GtkWidget*>(gobj()), &x, &y);
 }
 
 bool Widget::is_ancestor(Widget & ancestor) const
@@ -6019,72 +5482,82 @@ bool Widget::translate_coordinates(Widget& dest_widget, int src_x, int src_y, in
 
 void Widget::set_style(const Glib::RefPtr<Style>& style)
 {
-gtk_widget_set_style(gobj(), Glib::unwrap(style)); 
+  gtk_widget_set_style(gobj(), Glib::unwrap(style));
 }
 
 void Widget::ensure_style()
 {
-gtk_widget_ensure_style(gobj()); 
+  gtk_widget_ensure_style(gobj());
 }
 
 Glib::RefPtr<Style> Widget::get_style()
 {
 
   Glib::RefPtr<Style> retvalue = Glib::wrap(gtk_widget_get_style(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Style> Widget::get_style() const
 {
-  return const_cast<Widget*>(this)->get_style();
+
+  Glib::RefPtr<const Style> retvalue = Glib::wrap(gtk_widget_get_style(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Widget::modify_style(const Glib::RefPtr<RcStyle>& style)
 {
-gtk_widget_modify_style(gobj(), Glib::unwrap(style)); 
+  gtk_widget_modify_style(gobj(), Glib::unwrap(style));
 }
 
 Glib::RefPtr<RcStyle> Widget::get_modifier_style()
 {
 
   Glib::RefPtr<RcStyle> retvalue = Glib::wrap(gtk_widget_get_modifier_style(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const RcStyle> Widget::get_modifier_style() const
 {
-  return const_cast<Widget*>(this)->get_modifier_style();
+
+  Glib::RefPtr<const RcStyle> retvalue = Glib::wrap(gtk_widget_get_modifier_style(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Widget::modify_fg(StateType state, const Gdk::Color& color)
 {
-gtk_widget_modify_fg(gobj(), ((GtkStateType)(state)), (color).gobj()); 
+  gtk_widget_modify_fg(gobj(), ((GtkStateType)(state)), (color).gobj());
 }
 
 void Widget::modify_bg(StateType state, const Gdk::Color& color)
 {
-gtk_widget_modify_bg(gobj(), ((GtkStateType)(state)), (color).gobj()); 
+  gtk_widget_modify_bg(gobj(), ((GtkStateType)(state)), (color).gobj());
 }
 
 void Widget::modify_text(StateType state, const Gdk::Color& color)
 {
-gtk_widget_modify_text(gobj(), ((GtkStateType)(state)), (color).gobj()); 
+  gtk_widget_modify_text(gobj(), ((GtkStateType)(state)), (color).gobj());
 }
 
 void Widget::modify_base(StateType state, const Gdk::Color& color)
 {
-gtk_widget_modify_base(gobj(), ((GtkStateType)(state)), (color).gobj()); 
+  gtk_widget_modify_base(gobj(), ((GtkStateType)(state)), (color).gobj());
 }
 
 void Widget::modify_font(const Pango::FontDescription& font_desc)
 {
-gtk_widget_modify_font(gobj(), const_cast<PangoFontDescription*>((font_desc).gobj())); 
+  gtk_widget_modify_font(gobj(), const_cast<PangoFontDescription*>((font_desc).gobj()));
 }
 
 Glib::RefPtr<Pango::Context> Widget::create_pango_context()
@@ -6096,10 +5569,10 @@ Glib::RefPtr<Pango::Context> Widget::get_pango_context()
 {
 
   Glib::RefPtr<Pango::Context> retvalue = Glib::wrap(gtk_widget_get_pango_context(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<Pango::Layout> Widget::create_pango_layout(const Glib::ustring& text)
@@ -6114,7 +5587,7 @@ Glib::RefPtr<Gdk::Pixbuf> Widget::render_icon(const StockID& stock_id, IconSize
 
 void Widget::set_composite_name(const Glib::ustring& name)
 {
-gtk_widget_set_composite_name(gobj(), name.c_str()); 
+  gtk_widget_set_composite_name(gobj(), name.c_str());
 }
 
 Glib::ustring Widget::get_composite_name() const
@@ -6124,39 +5597,34 @@ Glib::ustring Widget::get_composite_name() const
 
 void Widget::reset_rc_styles()
 {
-gtk_widget_reset_rc_styles(gobj()); 
+  gtk_widget_reset_rc_styles(gobj());
 }
 
 void Widget::push_colormap(const Glib::RefPtr<const Gdk::Colormap>& cmap)
 {
-gtk_widget_push_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(cmap)));
+  gtk_widget_push_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(cmap)));
 }
 
-
 void Widget::pop_colormap()
 {
-gtk_widget_pop_colormap();
+  gtk_widget_pop_colormap();
 }
 
-
 void Widget::push_composite_child()
 {
-gtk_widget_push_composite_child();
+  gtk_widget_push_composite_child();
 }
 
-
 void Widget::pop_composite_child()
 {
-gtk_widget_pop_composite_child();
+  gtk_widget_pop_composite_child();
 }
 
-
 void Widget::set_default_colormap(const Glib::RefPtr<const Gdk::Colormap>& colormap)
 {
-gtk_widget_set_default_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap)));
+  gtk_widget_set_default_colormap(const_cast<GdkColormap*>(Glib::unwrap<Gdk::Colormap>(colormap)));
 }
 
-
 Glib::RefPtr<Style> Widget::get_default_style()
 {
 
@@ -6167,7 +5635,6 @@ Glib::RefPtr<Style> Widget::get_default_style()
   return retvalue;
 }
 
-
 Glib::RefPtr<Gdk::Colormap> Widget::get_default_colormap()
 {
 
@@ -6178,7 +5645,6 @@ Glib::RefPtr<Gdk::Colormap> Widget::get_default_colormap()
   return retvalue;
 }
 
-
 Glib::RefPtr<Gdk::Visual> Widget::get_default_visual()
 {
 
@@ -6189,10 +5655,9 @@ Glib::RefPtr<Gdk::Visual> Widget::get_default_visual()
   return retvalue;
 }
 
-
 void Widget::set_direction(TextDirection dir)
 {
-gtk_widget_set_direction(gobj(), ((GtkTextDirection)(dir))); 
+  gtk_widget_set_direction(gobj(), ((GtkTextDirection)(dir)));
 }
 
 TextDirection Widget::get_direction()
@@ -6202,29 +5667,22 @@ TextDirection Widget::get_direction()
 
 void Widget::set_default_direction(TextDirection dir)
 {
-gtk_widget_set_default_direction(((GtkTextDirection)(dir)));
+  gtk_widget_set_default_direction(((GtkTextDirection)(dir)));
 }
 
-
 TextDirection Widget::get_default_direction()
 {
   return ((TextDirection)(gtk_widget_get_default_direction()));
 }
 
-
 void Widget::shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y)
 {
-gtk_widget_shape_combine_mask(gobj(), const_cast<GdkBitmap*>(Glib::unwrap<Gdk::Bitmap>(shape_mask)), offset_x, offset_y); 
-}
-
-void Widget::input_shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y)
-{
-gtk_widget_input_shape_combine_mask(gobj(), const_cast<GdkBitmap*>(Glib::unwrap<Gdk::Bitmap>(shape_mask)), offset_x, offset_y); 
+  gtk_widget_shape_combine_mask(gobj(), const_cast<GdkBitmap*>(Glib::unwrap<Gdk::Bitmap>(shape_mask)), offset_x, offset_y);
 }
 
 void Widget::reset_shapes()
 {
-gtk_widget_reset_shapes(gobj()); 
+  gtk_widget_reset_shapes(gobj());
 }
 
 Glib::ListHandle<Widget*> Widget::list_mnemonic_labels()
@@ -6239,37 +5697,37 @@ Glib::ListHandle<const Widget*> Widget::list_mnemonic_labels() const
 
 void Widget::add_mnemonic_label(Widget& label)
 {
-gtk_widget_add_mnemonic_label(gobj(), (label).gobj()); 
+  gtk_widget_add_mnemonic_label(gobj(), (label).gobj());
 }
 
 void Widget::remove_mnemonic_label(Widget& label)
 {
-gtk_widget_remove_mnemonic_label(gobj(), (label).gobj()); 
+  gtk_widget_remove_mnemonic_label(gobj(), (label).gobj());
 }
 
 void Widget::drag_get_data(const Glib::RefPtr<Gdk::DragContext>& context, Glib::ustring& target, guint32 time)
 {
-gtk_drag_get_data(gobj(), Glib::unwrap(context), Gdk::AtomString::to_c_type(target), time); 
+  gtk_drag_get_data(gobj(), Glib::unwrap(context), Gdk::AtomString::to_c_type(target), time);
 }
 
 void Widget::drag_highlight()
 {
-gtk_drag_highlight(gobj()); 
+  gtk_drag_highlight(gobj());
 }
 
 void Widget::drag_unhighlight()
 {
-gtk_drag_unhighlight(gobj()); 
+  gtk_drag_unhighlight(gobj());
 }
 
 void Widget::drag_dest_set_proxy(const Glib::RefPtr<Gdk::Window>& proxy_window, Gdk::DragProtocol protocol, bool use_coordinates)
 {
-gtk_drag_dest_set_proxy(gobj(), Glib::unwrap(proxy_window), ((GdkDragProtocol)(protocol)), static_cast<int>(use_coordinates)); 
+  gtk_drag_dest_set_proxy(gobj(), Glib::unwrap(proxy_window), ((GdkDragProtocol)(protocol)), static_cast<int>(use_coordinates));
 }
 
 void Widget::drag_dest_unset()
 {
-gtk_drag_dest_unset(gobj()); 
+  gtk_drag_dest_unset(gobj());
 }
 
 Glib::ustring Widget::drag_dest_find_target(const Glib::RefPtr<Gdk::DragContext>& context, const Glib::RefPtr<TargetList>& target_list) const
@@ -6281,85 +5739,85 @@ Glib::RefPtr<TargetList> Widget::drag_dest_get_target_list()
 {
 
   Glib::RefPtr<TargetList> retvalue = Glib::wrap(gtk_drag_dest_get_target_list(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const TargetList> Widget::drag_dest_get_target_list() const
 {
-  return const_cast<Widget*>(this)->drag_dest_get_target_list();
+
+  Glib::RefPtr<const TargetList> retvalue = Glib::wrap(gtk_drag_dest_get_target_list(const_cast<GtkWidget*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Widget::drag_dest_set_target_list(const Glib::RefPtr<TargetList>& target_list)
 {
-gtk_drag_dest_set_target_list(gobj(), const_cast<GtkTargetList*>(Glib::unwrap(target_list))); 
+  gtk_drag_dest_set_target_list(gobj(), const_cast<GtkTargetList*>(Glib::unwrap(target_list)));
 }
 
 void Widget::drag_dest_add_text_targets()
 {
-gtk_drag_dest_add_text_targets(gobj()); 
+  gtk_drag_dest_add_text_targets(gobj());
 }
 
 void Widget::drag_dest_add_image_targets()
 {
-gtk_drag_dest_add_image_targets(gobj()); 
+  gtk_drag_dest_add_image_targets(gobj());
 }
 
 void Widget::drag_dest_add_uri_targets()
 {
-gtk_drag_dest_add_uri_targets(gobj()); 
+  gtk_drag_dest_add_uri_targets(gobj());
 }
 
 void Widget::drag_source_unset()
 {
-gtk_drag_source_unset(gobj()); 
+  gtk_drag_source_unset(gobj());
 }
 
 void Widget::drag_source_set_icon(const Glib::RefPtr<Gdk::Colormap>& colormap, const Glib::RefPtr<Gdk::Pixmap>& pixmap, const Glib::RefPtr<Gdk::Bitmap>& mask)
 {
-gtk_drag_source_set_icon(gobj(), Glib::unwrap(colormap), Glib::unwrap(pixmap), Glib::unwrap(mask)); 
+  gtk_drag_source_set_icon(gobj(), Glib::unwrap(colormap), Glib::unwrap(pixmap), Glib::unwrap(mask));
 }
 
 void Widget::drag_source_set_icon(const Glib::RefPtr<Gdk::Pixbuf>& pixbuf)
 {
-gtk_drag_source_set_icon_pixbuf(gobj(), Glib::unwrap(pixbuf)); 
+  gtk_drag_source_set_icon_pixbuf(gobj(), Glib::unwrap(pixbuf));
 }
 
 void Widget::drag_source_set_icon(const StockID& stock_id)
 {
-gtk_drag_source_set_icon_stock(gobj(), (stock_id).get_c_str()); 
-}
-
-void Widget::drag_source_set_icon(const Glib::ustring& icon_name)
-{
-gtk_drag_source_set_icon_name(gobj(), icon_name.c_str()); 
+  gtk_drag_source_set_icon_stock(gobj(), (stock_id).get_c_str());
 }
 
 void Widget::drag_source_add_text_targets()
 {
-gtk_drag_source_add_text_targets(gobj()); 
+  gtk_drag_source_add_text_targets(gobj());
 }
 
 void Widget::drag_source_add_uri_targets()
 {
-gtk_drag_source_add_uri_targets(gobj()); 
+  gtk_drag_source_add_uri_targets(gobj());
 }
 
 void Widget::drag_source_add_image_targets()
 {
-gtk_drag_source_add_image_targets(gobj()); 
+  gtk_drag_source_add_image_targets(gobj());
 }
 
 Glib::RefPtr<Gdk::DragContext> Widget::drag_begin(const Glib::RefPtr<TargetList>& targets, Gdk::DragAction actions, int button, GdkEvent* event)
 {
 
   Glib::RefPtr<Gdk::DragContext> retvalue = Glib::wrap(gtk_drag_begin(gobj(), const_cast<GtkTargetList*>(Glib::unwrap(targets)), ((GdkDragAction)(actions)), button, event), true);
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 bool Widget::drag_check_threshold(int start_x, int start_y, int current_x, int current_y)
@@ -6369,7 +5827,7 @@ bool Widget::drag_check_threshold(int start_x, int start_y, int current_x, int c
 
 void Widget::queue_resize_no_redraw()
 {
-gtk_widget_queue_resize_no_redraw(gobj()); 
+  gtk_widget_queue_resize_no_redraw(gobj());
 }
 
 bool Widget::get_no_show_all() const
@@ -6379,70 +5837,40 @@ bool Widget::get_no_show_all() const
 
 void Widget::set_no_show_all(bool no_show_all)
 {
-gtk_widget_set_no_show_all(gobj(), static_cast<int>(no_show_all)); 
+  gtk_widget_set_no_show_all(gobj(), static_cast<int>(no_show_all));
 }
 
 void Widget::set_parent(Widget& parent)
 {
-gtk_widget_set_parent(gobj(), (parent).gobj()); 
+  gtk_widget_set_parent(gobj(), (parent).gobj());
 }
 
 void Widget::unparent()
 {
-gtk_widget_unparent(gobj()); 
-}
-
-void Widget::map()
-{
-gtk_widget_map(gobj()); 
-}
-
-void Widget::unmap()
-{
-gtk_widget_unmap(gobj()); 
-}
-
-bool Widget::is_composited() const
-{
-  return gtk_widget_is_composited(const_cast<GtkWidget*>(gobj()));
-}
-
-Glib::RefPtr<Action> Widget::get_action()
-{
-
-  Glib::RefPtr<Action> retvalue = Glib::wrap(gtk_widget_get_action(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const Action> Widget::get_action() const
-{
-  return const_cast<Widget*>(this)->get_action();
+  gtk_widget_unparent(gobj());
 }
 
- Gtk::StateType Widget::get_state() const
+Gtk::StateType Widget::get_state() const
 {
   return static_cast<StateType>(gobj()->state);
 }
- 
- Gtk::StateType Widget::get_saved_state() const
+
+Gtk::StateType Widget::get_saved_state() const
 {
   return static_cast<StateType>(gobj()->saved_state);
 }
- 
- Requisition Widget::get_requisition() const
+
+Requisition Widget::get_requisition() const
 {
   return (Requisition)(gobj()->requisition);
 }
- 
- Allocation Widget::get_allocation() const
+
+Allocation Widget::get_allocation() const
 {
   return (Allocation)(Glib::wrap(&gobj()->allocation));
 }
- 
- Glib::RefPtr<Gdk::Window> Widget::get_window()
+
+Glib::RefPtr<Gdk::Window> Widget::get_window()
 {
   Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->window)));
 
@@ -6461,7 +5889,7 @@ Glib::RefPtr<const Gdk::Window> Widget::get_window() const
 
   return ref_ptr;
 }
- 
+
 Widget::Widget()
 :
   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
@@ -6469,32 +5897,42 @@ Widget::Widget()
 {
   }
 
+void Widget::map()
+{
+  gtk_widget_map(gobj());
+}
+
+void Widget::unmap()
+{
+  gtk_widget_unmap(gobj());
+}
+
 void Widget::realize()
 {
-gtk_widget_realize(gobj()); 
+  gtk_widget_realize(gobj());
 }
 
 void Widget::unrealize()
 {
-gtk_widget_unrealize(gobj()); 
+  gtk_widget_unrealize(gobj());
 }
 
 void Widget::get_child_requisition(Requisition& requisition) const
 {
-gtk_widget_get_child_requisition(const_cast<GtkWidget*>(gobj()), (GtkRequisition*)(&requisition)); 
+  gtk_widget_get_child_requisition(const_cast<GtkWidget*>(gobj()), (GtkRequisition*)(&requisition));
 }
 
 void Widget::get_style_property_value(const Glib::ustring& the_property_name, Glib::ValueBase& value) const
 {
-gtk_widget_style_get_property(const_cast<GtkWidget*>(gobj()), the_property_name.c_str(), (value).gobj()); 
+  gtk_widget_style_get_property(const_cast<GtkWidget*>(gobj()), the_property_name.c_str(), (value).gobj());
 }
 
- void Widget::set_allocation(const Allocation& value)
+void Widget::set_allocation(const Allocation& value)
 {
   gobj()->allocation = (GtkAllocation)(*(value.gobj()));
 }
- 
- void Widget::set_window(const Glib::RefPtr<Gdk::Window>& value)
+
+void Widget::set_window(const Glib::RefPtr<Gdk::Window>& value)
 {
   Glib::RefPtr<Gdk::Window> valueOld(Glib::wrap((GdkWindowObject*)(gobj()->window))); //Take possession of the old one, unref-ing it in the destructor.
 
@@ -6503,345 +5941,287 @@ gtk_widget_style_get_property(const_cast<GtkWidget*>(gobj()), the_property_name.
 
   gobj()->window = Glib::unwrap(value);
 }
- 
+
 
 Glib::SignalProxy0< void > Widget::signal_show()
 {
   return Glib::SignalProxy0< void >(this, &Widget_signal_show_info);
 }
 
-
 Glib::SignalProxy0< void > Widget::signal_hide()
 {
   return Glib::SignalProxy0< void >(this, &Widget_signal_hide_info);
 }
 
-
 Glib::SignalProxy0< void > Widget::signal_map()
 {
   return Glib::SignalProxy0< void >(this, &Widget_signal_map_info);
 }
 
-
 Glib::SignalProxy0< void > Widget::signal_unmap()
 {
   return Glib::SignalProxy0< void >(this, &Widget_signal_unmap_info);
 }
 
-
 Glib::SignalProxy0< void > Widget::signal_realize()
 {
   return Glib::SignalProxy0< void >(this, &Widget_signal_realize_info);
 }
 
-
 Glib::SignalProxy0< void > Widget::signal_unrealize()
 {
   return Glib::SignalProxy0< void >(this, &Widget_signal_unrealize_info);
 }
 
-
 Glib::SignalProxy1< void,Requisition* > Widget::signal_size_request()
 {
   return Glib::SignalProxy1< void,Requisition* >(this, &Widget_signal_size_request_info);
 }
 
-
 Glib::SignalProxy1< void,Allocation& > Widget::signal_size_allocate()
 {
   return Glib::SignalProxy1< void,Allocation& >(this, &Widget_signal_size_allocate_info);
 }
 
-
 Glib::SignalProxy1< void,Gtk::StateType > Widget::signal_state_changed()
 {
   return Glib::SignalProxy1< void,Gtk::StateType >(this, &Widget_signal_state_changed_info);
 }
 
-
 Glib::SignalProxy1< void,Widget* > Widget::signal_parent_changed()
 {
   return Glib::SignalProxy1< void,Widget* >(this, &Widget_signal_parent_changed_info);
 }
 
-
 Glib::SignalProxy1< void,Widget* > Widget::signal_hierarchy_changed()
 {
   return Glib::SignalProxy1< void,Widget* >(this, &Widget_signal_hierarchy_changed_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Style>& > Widget::signal_style_changed()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Style>& >(this, &Widget_signal_style_changed_info);
 }
 
-
 Glib::SignalProxy1< void,TextDirection > Widget::signal_direction_changed()
 {
   return Glib::SignalProxy1< void,TextDirection >(this, &Widget_signal_direction_changed_info);
 }
 
-
 Glib::SignalProxy1< void,bool > Widget::signal_grab_notify()
 {
   return Glib::SignalProxy1< void,bool >(this, &Widget_signal_grab_notify_info);
 }
 
-
 Glib::SignalProxy1< void,GParamSpec* > Widget::signal_child_notify()
 {
   return Glib::SignalProxy1< void,GParamSpec* >(this, &Widget_signal_child_notify_info);
 }
 
-
 Glib::SignalProxy1< bool,bool > Widget::signal_mnemonic_activate()
 {
   return Glib::SignalProxy1< bool,bool >(this, &Widget_signal_mnemonic_activate_info);
 }
 
-
 Glib::SignalProxy0< void > Widget::signal_grab_focus()
 {
   return Glib::SignalProxy0< void >(this, &Widget_signal_grab_focus_info);
 }
 
-
 Glib::SignalProxy1< bool,DirectionType > Widget::signal_focus()
 {
   return Glib::SignalProxy1< bool,DirectionType >(this, &Widget_signal_focus_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEvent* > Widget::signal_event()
 {
   return Glib::SignalProxy1< bool,GdkEvent* >(this, &Widget_signal_event_info);
 }
 
-
 Glib::SignalProxy1< void,GdkEvent* > Widget::signal_event_after()
 {
   return Glib::SignalProxy1< void,GdkEvent* >(this, &Widget_signal_event_after_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventButton* > Widget::signal_button_press_event()
 {
   return Glib::SignalProxy1< bool,GdkEventButton* >(this, &Widget_signal_button_press_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventButton* > Widget::signal_button_release_event()
 {
   return Glib::SignalProxy1< bool,GdkEventButton* >(this, &Widget_signal_button_release_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventScroll* > Widget::signal_scroll_event()
 {
   return Glib::SignalProxy1< bool,GdkEventScroll* >(this, &Widget_signal_scroll_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventMotion* > Widget::signal_motion_notify_event()
 {
   return Glib::SignalProxy1< bool,GdkEventMotion* >(this, &Widget_signal_motion_notify_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_delete_event()
 {
   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_delete_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventExpose* > Widget::signal_expose_event()
 {
   return Glib::SignalProxy1< bool,GdkEventExpose* >(this, &Widget_signal_expose_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventKey* > Widget::signal_key_press_event()
 {
   return Glib::SignalProxy1< bool,GdkEventKey* >(this, &Widget_signal_key_press_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventKey* > Widget::signal_key_release_event()
 {
   return Glib::SignalProxy1< bool,GdkEventKey* >(this, &Widget_signal_key_release_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventCrossing* > Widget::signal_enter_notify_event()
 {
   return Glib::SignalProxy1< bool,GdkEventCrossing* >(this, &Widget_signal_enter_notify_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventCrossing* > Widget::signal_leave_notify_event()
 {
   return Glib::SignalProxy1< bool,GdkEventCrossing* >(this, &Widget_signal_leave_notify_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventConfigure* > Widget::signal_configure_event()
 {
   return Glib::SignalProxy1< bool,GdkEventConfigure* >(this, &Widget_signal_configure_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventFocus* > Widget::signal_focus_in_event()
 {
   return Glib::SignalProxy1< bool,GdkEventFocus* >(this, &Widget_signal_focus_in_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventFocus* > Widget::signal_focus_out_event()
 {
   return Glib::SignalProxy1< bool,GdkEventFocus* >(this, &Widget_signal_focus_out_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_map_event()
 {
   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_map_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_unmap_event()
 {
   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_unmap_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventProperty* > Widget::signal_property_notify_event()
 {
   return Glib::SignalProxy1< bool,GdkEventProperty* >(this, &Widget_signal_property_notify_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_clear_event()
 {
   return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_clear_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_request_event()
 {
   return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_request_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventSelection* > Widget::signal_selection_notify_event()
 {
   return Glib::SignalProxy1< bool,GdkEventSelection* >(this, &Widget_signal_selection_notify_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventProximity* > Widget::signal_proximity_in_event()
 {
   return Glib::SignalProxy1< bool,GdkEventProximity* >(this, &Widget_signal_proximity_in_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventProximity* > Widget::signal_proximity_out_event()
 {
   return Glib::SignalProxy1< bool,GdkEventProximity* >(this, &Widget_signal_proximity_out_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventVisibility* > Widget::signal_visibility_notify_event()
 {
   return Glib::SignalProxy1< bool,GdkEventVisibility* >(this, &Widget_signal_visibility_notify_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventClient* > Widget::signal_client_event()
 {
   return Glib::SignalProxy1< bool,GdkEventClient* >(this, &Widget_signal_client_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventAny* > Widget::signal_no_expose_event()
 {
   return Glib::SignalProxy1< bool,GdkEventAny* >(this, &Widget_signal_no_expose_event_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEventWindowState* > Widget::signal_window_state_event()
 {
   return Glib::SignalProxy1< bool,GdkEventWindowState* >(this, &Widget_signal_window_state_event_info);
 }
 
-
 Glib::SignalProxy3< void,SelectionData&,guint,guint > Widget::signal_selection_get()
 {
   return Glib::SignalProxy3< void,SelectionData&,guint,guint >(this, &Widget_signal_selection_get_info);
 }
 
-
 Glib::SignalProxy2< void,const SelectionData&,guint > Widget::signal_selection_received()
 {
   return Glib::SignalProxy2< void,const SelectionData&,guint >(this, &Widget_signal_selection_received_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_begin()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_begin_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_end()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_end_info);
 }
 
-
 Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > Widget::signal_drag_data_get()
 {
   return Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint >(this, &Widget_signal_drag_data_get_info);
 }
 
-
 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > Widget::signal_drag_data_delete()
 {
   return Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& >(this, &Widget_signal_drag_data_delete_info);
 }
 
-
 Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint > Widget::signal_drag_leave()
 {
   return Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint >(this, &Widget_signal_drag_leave_info);
 }
 
-
 Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > Widget::signal_drag_motion()
 {
   return Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint >(this, &Widget_signal_drag_motion_info);
 }
 
-
 Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > Widget::signal_drag_drop()
 {
   return Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint >(this, &Widget_signal_drag_drop_info);
 }
 
-
 Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > Widget::signal_drag_data_received()
 {
   return Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint >(this, &Widget_signal_drag_data_received_info);
 }
 
-
-#ifdef GTKMM_ATKMM_ENABLED
 Glib::SignalProxy0< Glib::RefPtr<Atk::Object> > Widget::signal_get_accessible()
 {
   return Glib::SignalProxy0< Glib::RefPtr<Atk::Object> >(this, &Widget_signal_get_accessible_info);
 }
-#endif // GTKMM_ATKMM_ENABLED
-
 
 Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& > Widget::signal_screen_changed()
 {
@@ -6849,231 +6229,162 @@ Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& > Widget::signal_scree
 }
 
 
-Glib::SignalProxy0< void > Widget::signal_composited_changed()
-{
-  return Glib::SignalProxy0< void >(this, &Widget_signal_composited_changed_info);
-}
-
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Widget::property_name() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Widget::property_name() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "name");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Container*> Widget::property_parent() 
 {
   return Glib::PropertyProxy<Container*>(this, "parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Container*> Widget::property_parent() const
 {
   return Glib::PropertyProxy_ReadOnly<Container*>(this, "parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Widget::property_width_request() 
 {
   return Glib::PropertyProxy<int>(this, "width-request");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Widget::property_width_request() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "width-request");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Widget::property_height_request() 
 {
   return Glib::PropertyProxy<int>(this, "height-request");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Widget::property_height_request() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "height-request");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_sensitive() 
 {
   return Glib::PropertyProxy<bool>(this, "sensitive");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_sensitive() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "sensitive");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_app_paintable() 
 {
   return Glib::PropertyProxy<bool>(this, "app-paintable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_app_paintable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "app-paintable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_can_focus() 
 {
   return Glib::PropertyProxy<bool>(this, "can-focus");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_can_focus() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "can-focus");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_has_focus() 
 {
   return Glib::PropertyProxy<bool>(this, "has-focus");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_has_focus() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-focus");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_can_default() 
 {
   return Glib::PropertyProxy<bool>(this, "can-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_can_default() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "can-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_has_default() 
 {
   return Glib::PropertyProxy<bool>(this, "has-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_has_default() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_receives_default() 
 {
   return Glib::PropertyProxy<bool>(this, "receives-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_receives_default() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "receives-default");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_composite_child() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "composite-child");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Style> > Widget::property_style() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Style> >(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> > Widget::property_style() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> >(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::EventMask> Widget::property_events() 
 {
   return Glib::PropertyProxy<Gdk::EventMask>(this, "events");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::EventMask> Widget::property_events() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::EventMask>(this, "events");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::ExtensionMode> Widget::property_extension_events() 
 {
   return Glib::PropertyProxy<Gdk::ExtensionMode>(this, "extension-events");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode> Widget::property_extension_events() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode>(this, "extension-events");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Widget::on_show()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7083,6 +6394,7 @@ void Gtk::Widget::on_show()
   if(base && base->show)
     (*base->show)(gobj());
 }
+
 void Gtk::Widget::on_hide()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7092,6 +6404,7 @@ void Gtk::Widget::on_hide()
   if(base && base->hide)
     (*base->hide)(gobj());
 }
+
 void Gtk::Widget::on_map()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7101,6 +6414,7 @@ void Gtk::Widget::on_map()
   if(base && base->map)
     (*base->map)(gobj());
 }
+
 void Gtk::Widget::on_unmap()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7110,6 +6424,7 @@ void Gtk::Widget::on_unmap()
   if(base && base->unmap)
     (*base->unmap)(gobj());
 }
+
 void Gtk::Widget::on_realize()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7119,6 +6434,7 @@ void Gtk::Widget::on_realize()
   if(base && base->realize)
     (*base->realize)(gobj());
 }
+
 void Gtk::Widget::on_unrealize()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7128,6 +6444,7 @@ void Gtk::Widget::on_unrealize()
   if(base && base->unrealize)
     (*base->unrealize)(gobj());
 }
+
 void Gtk::Widget::on_size_request(Requisition* requisition)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7137,6 +6454,7 @@ void Gtk::Widget::on_size_request(Requisition* requisition)
   if(base && base->size_request)
     (*base->size_request)(gobj(),(GtkRequisition*)(requisition));
 }
+
 void Gtk::Widget::on_size_allocate(Allocation& allocation)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7146,6 +6464,7 @@ void Gtk::Widget::on_size_allocate(Allocation& allocation)
   if(base && base->size_allocate)
     (*base->size_allocate)(gobj(),(GtkAllocation*)(allocation.gobj()));
 }
+
 void Gtk::Widget::on_state_changed(Gtk::StateType previous_state)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7155,6 +6474,7 @@ void Gtk::Widget::on_state_changed(Gtk::StateType previous_state)
   if(base && base->state_changed)
     (*base->state_changed)(gobj(),((GtkStateType)(previous_state)));
 }
+
 void Gtk::Widget::on_parent_changed(Widget* previous_parent)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7164,6 +6484,7 @@ void Gtk::Widget::on_parent_changed(Widget* previous_parent)
   if(base && base->parent_set)
     (*base->parent_set)(gobj(),(GtkWidget*)Glib::unwrap(previous_parent));
 }
+
 void Gtk::Widget::on_hierarchy_changed(Widget* previous_toplevel)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7173,6 +6494,7 @@ void Gtk::Widget::on_hierarchy_changed(Widget* previous_toplevel)
   if(base && base->hierarchy_changed)
     (*base->hierarchy_changed)(gobj(),(GtkWidget*)Glib::unwrap(previous_toplevel));
 }
+
 void Gtk::Widget::on_style_changed(const Glib::RefPtr<Style>& previous_style)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7182,6 +6504,7 @@ void Gtk::Widget::on_style_changed(const Glib::RefPtr<Style>& previous_style)
   if(base && base->style_set)
     (*base->style_set)(gobj(),Glib::unwrap(previous_style));
 }
+
 void Gtk::Widget::on_direction_changed(TextDirection direction)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7191,6 +6514,7 @@ void Gtk::Widget::on_direction_changed(TextDirection direction)
   if(base && base->direction_changed)
     (*base->direction_changed)(gobj(),((GtkTextDirection)(direction)));
 }
+
 void Gtk::Widget::on_grab_notify(bool was_grabbed)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7200,6 +6524,7 @@ void Gtk::Widget::on_grab_notify(bool was_grabbed)
   if(base && base->grab_notify)
     (*base->grab_notify)(gobj(),static_cast<int>(was_grabbed));
 }
+
 void Gtk::Widget::on_child_notify(GParamSpec* pspec)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7209,6 +6534,7 @@ void Gtk::Widget::on_child_notify(GParamSpec* pspec)
   if(base && base->child_notify)
     (*base->child_notify)(gobj(),pspec);
 }
+
 bool Gtk::Widget::on_mnemonic_activate(bool group_cycling)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7221,6 +6547,7 @@ bool Gtk::Widget::on_mnemonic_activate(bool group_cycling)
   typedef bool RType;
   return RType();
 }
+
 void Gtk::Widget::on_grab_focus()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7230,6 +6557,7 @@ void Gtk::Widget::on_grab_focus()
   if(base && base->grab_focus)
     (*base->grab_focus)(gobj());
 }
+
 bool Gtk::Widget::on_focus(DirectionType direction)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7242,6 +6570,7 @@ bool Gtk::Widget::on_focus(DirectionType direction)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_event(GdkEvent* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7254,6 +6583,7 @@ bool Gtk::Widget::on_event(GdkEvent* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_button_press_event(GdkEventButton* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7266,6 +6596,7 @@ bool Gtk::Widget::on_button_press_event(GdkEventButton* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_button_release_event(GdkEventButton* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7278,6 +6609,7 @@ bool Gtk::Widget::on_button_release_event(GdkEventButton* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_scroll_event(GdkEventScroll* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7290,6 +6622,7 @@ bool Gtk::Widget::on_scroll_event(GdkEventScroll* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_motion_notify_event(GdkEventMotion* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7302,6 +6635,7 @@ bool Gtk::Widget::on_motion_notify_event(GdkEventMotion* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_delete_event(GdkEventAny* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7314,6 +6648,7 @@ bool Gtk::Widget::on_delete_event(GdkEventAny* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_expose_event(GdkEventExpose* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7326,6 +6661,7 @@ bool Gtk::Widget::on_expose_event(GdkEventExpose* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_key_press_event(GdkEventKey* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7338,6 +6674,7 @@ bool Gtk::Widget::on_key_press_event(GdkEventKey* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_key_release_event(GdkEventKey* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7350,6 +6687,7 @@ bool Gtk::Widget::on_key_release_event(GdkEventKey* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_enter_notify_event(GdkEventCrossing* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7362,6 +6700,7 @@ bool Gtk::Widget::on_enter_notify_event(GdkEventCrossing* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_leave_notify_event(GdkEventCrossing* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7374,6 +6713,7 @@ bool Gtk::Widget::on_leave_notify_event(GdkEventCrossing* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_configure_event(GdkEventConfigure* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7386,6 +6726,7 @@ bool Gtk::Widget::on_configure_event(GdkEventConfigure* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_focus_in_event(GdkEventFocus* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7398,6 +6739,7 @@ bool Gtk::Widget::on_focus_in_event(GdkEventFocus* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_focus_out_event(GdkEventFocus* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7410,6 +6752,7 @@ bool Gtk::Widget::on_focus_out_event(GdkEventFocus* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_map_event(GdkEventAny* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7422,6 +6765,7 @@ bool Gtk::Widget::on_map_event(GdkEventAny* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_unmap_event(GdkEventAny* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7434,6 +6778,7 @@ bool Gtk::Widget::on_unmap_event(GdkEventAny* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_property_notify_event(GdkEventProperty* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7446,6 +6791,7 @@ bool Gtk::Widget::on_property_notify_event(GdkEventProperty* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_selection_clear_event(GdkEventSelection* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7458,6 +6804,7 @@ bool Gtk::Widget::on_selection_clear_event(GdkEventSelection* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_selection_request_event(GdkEventSelection* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7470,6 +6817,7 @@ bool Gtk::Widget::on_selection_request_event(GdkEventSelection* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_selection_notify_event(GdkEventSelection* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7482,6 +6830,7 @@ bool Gtk::Widget::on_selection_notify_event(GdkEventSelection* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_proximity_in_event(GdkEventProximity* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7494,6 +6843,7 @@ bool Gtk::Widget::on_proximity_in_event(GdkEventProximity* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_proximity_out_event(GdkEventProximity* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7506,6 +6856,7 @@ bool Gtk::Widget::on_proximity_out_event(GdkEventProximity* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_visibility_notify_event(GdkEventVisibility* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7518,6 +6869,7 @@ bool Gtk::Widget::on_visibility_notify_event(GdkEventVisibility* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_client_event(GdkEventClient* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7530,6 +6882,7 @@ bool Gtk::Widget::on_client_event(GdkEventClient* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_no_expose_event(GdkEventAny* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7542,6 +6895,7 @@ bool Gtk::Widget::on_no_expose_event(GdkEventAny* event)
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_window_state_event(GdkEventWindowState* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7554,6 +6908,7 @@ bool Gtk::Widget::on_window_state_event(GdkEventWindowState* event)
   typedef bool RType;
   return RType();
 }
+
 void Gtk::Widget::on_selection_get(SelectionData& selection_data, guint info, guint time)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7563,6 +6918,7 @@ void Gtk::Widget::on_selection_get(SelectionData& selection_data, guint info, gu
   if(base && base->selection_get)
     (*base->selection_get)(gobj(),(selection_data).gobj(),info,time);
 }
+
 void Gtk::Widget::on_selection_received(const SelectionData& selection_data, guint time)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7572,6 +6928,7 @@ void Gtk::Widget::on_selection_received(const SelectionData& selection_data, gui
   if(base && base->selection_received)
     (*base->selection_received)(gobj(),const_cast<GtkSelectionData*>((selection_data).gobj()),time);
 }
+
 void Gtk::Widget::on_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7581,6 +6938,7 @@ void Gtk::Widget::on_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
   if(base && base->drag_begin)
     (*base->drag_begin)(gobj(),Glib::unwrap(context));
 }
+
 void Gtk::Widget::on_drag_end(const Glib::RefPtr<Gdk::DragContext>& context)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7590,6 +6948,7 @@ void Gtk::Widget::on_drag_end(const Glib::RefPtr<Gdk::DragContext>& context)
   if(base && base->drag_end)
     (*base->drag_end)(gobj(),Glib::unwrap(context));
 }
+
 void Gtk::Widget::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, SelectionData& selection_data, guint info, guint time)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7599,6 +6958,7 @@ void Gtk::Widget::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context
   if(base && base->drag_data_get)
     (*base->drag_data_get)(gobj(),Glib::unwrap(context),(selection_data).gobj(),info,time);
 }
+
 void Gtk::Widget::on_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7608,6 +6968,7 @@ void Gtk::Widget::on_drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& cont
   if(base && base->drag_data_delete)
     (*base->drag_data_delete)(gobj(),Glib::unwrap(context));
 }
+
 void Gtk::Widget::on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7617,6 +6978,7 @@ void Gtk::Widget::on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, g
   if(base && base->drag_leave)
     (*base->drag_leave)(gobj(),Glib::unwrap(context),time);
 }
+
 bool Gtk::Widget::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7629,6 +6991,7 @@ bool Gtk::Widget::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context,
   typedef bool RType;
   return RType();
 }
+
 bool Gtk::Widget::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7641,6 +7004,7 @@ bool Gtk::Widget::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, in
   typedef bool RType;
   return RType();
 }
+
 void Gtk::Widget::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const SelectionData& selection_data, guint info, guint time)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7650,7 +7014,7 @@ void Gtk::Widget::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& co
   if(base && base->drag_data_received)
     (*base->drag_data_received)(gobj(),Glib::unwrap(context),x,y,const_cast<GtkSelectionData*>((selection_data).gobj()),info,time);
 }
-#ifdef GTKMM_ATKMM_ENABLED
+
 Glib::RefPtr<Atk::Object> Gtk::Widget::on_get_accessible()
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7663,7 +7027,7 @@ Glib::RefPtr<Atk::Object> Gtk::Widget::on_get_accessible()
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
-#endif // GTKMM_ATKMM_ENABLED
+
 void Gtk::Widget::on_screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_screen)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7673,9 +7037,8 @@ void Gtk::Widget::on_screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_sc
   if(base && base->screen_changed)
     (*base->screen_changed)(gobj(),Glib::unwrap(previous_screen));
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
+
 void Gtk::Widget::dispatch_child_properties_changed_vfunc(guint p1, GParamSpec** p2) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7685,6 +7048,7 @@ void Gtk::Widget::dispatch_child_properties_changed_vfunc(guint p1, GParamSpec**
   if(base && base->dispatch_child_properties_changed)
     (*base->dispatch_child_properties_changed)(gobj(),p1,p2);
 }
+
 void Gtk::Widget::show_all_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7694,6 +7058,7 @@ void Gtk::Widget::show_all_vfunc()
   if(base && base->show_all)
     (*base->show_all)(gobj());
 }
+
 void Gtk::Widget::hide_all_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7703,7 +7068,7 @@ void Gtk::Widget::hide_all_vfunc()
   if(base && base->hide_all)
     (*base->hide_all)(gobj());
 }
-#ifdef GTKMM_ATKMM_ENABLED
+
 Glib::RefPtr<Atk::Object> Gtk::Widget::get_accessible_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -7711,13 +7076,11 @@ Glib::RefPtr<Atk::Object> Gtk::Widget::get_accessible_vfunc()
   );
 
   if(base && base->get_accessible)
-    return Glib::wrap((*base->get_accessible)(gobj()), true);
+    return Glib::wrap((*base->get_accessible)(gobj()));
 
   typedef Glib::RefPtr<Atk::Object> RType;
   return RType();
 }
-#endif // GTKMM_ATKMM_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/widget.h b/libs/gtkmm2/gtk/gtkmm/widget.h
index 4f2e8fc6f3..36877d402d 100644
--- a/libs/gtkmm2/gtk/gtkmm/widget.h
+++ b/libs/gtkmm2/gtk/gtkmm/widget.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_WIDGET_H
 #define _GTKMM_WIDGET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -27,13 +26,8 @@
  
 #include <pangomm/context.h>
 #include <pangomm/layout.h>
-
-#include <gtkmmconfig.h> //For GTKMM_ATKMM_ENABLED
-#ifdef GTKMM_ATKMM_ENABLED
 #include <atkmm/object.h>
 #include <atkmm/implementor.h>
-#endif //GTKMM_ATKMM_ENABLED
-
 #include <gdkmm/event.h>
 #include <gdkmm/types.h>
 #include <gdkmm/window.h>
@@ -47,7 +41,6 @@
 #include <gtkmm/rc.h>
 #include <gtkmm/object.h>
 #include <gtkmm/clipboard.h>
-//#include <gtkmm/action.h>
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -55,7 +48,6 @@ extern "C"
 {
 typedef struct _GtkTargetEntry GtkTargetEntry;
 }
-
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -254,7 +246,6 @@ namespace Gtk
 {
 
 
-class Action;
 class Style;
 class AccelGroup;
 class Adjustment;
@@ -291,10 +282,8 @@ typedef Gdk::Rectangle Allocation;
  */
 
 class Widget
-: public Object
-#ifdef GTKMM_ATKMM_ENABLED
-  ,public Atk::Implementor
-#endif //GTKMM_ATKMM_ENABLED
+: public Object,
+  public Atk::Implementor
 {
   public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -337,16 +326,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_show();
   virtual void on_hide();
   virtual void on_map();
@@ -401,11 +385,8 @@ protected:
   virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
   virtual bool on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
   virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const SelectionData& selection_data, guint info, guint time);
-#ifdef GTKMM_ATKMM_ENABLED
   virtual Glib::RefPtr<Atk::Object> on_get_accessible();
-#endif // GTKMM_ATKMM_ENABLED
   virtual void on_screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_screen);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -527,9 +508,9 @@ public:
    */
   Requisition size_request() const;
   
-
-#ifndef GTKMM_DISABLE_DEPRECATED
-
+  
+  //Deprecated, because the Requisition should be an output parameter. This could never have been used.
+  
   /** This function is typically used when implementing a Gtk::Container
    * subclass.  Obtains the preferred size of a widget. The container
    * uses this information to arrange its child widgets and decide what
@@ -544,13 +525,11 @@ public:
    * a widget will actually be allocated.
    * 
    * See also get_child_requisition().
-   * @deprecated Use size_request() const.
    * @param requisition A Gtk::Requisition to be filled in.
    */
   void size_request(const Requisition& requisition);
-#endif // GTKMM_DISABLE_DEPRECATED
-
 
+  
   /** This function is only used by Gtk::Container subclasses, to assign a size
    * and position to their child widgets.
    * @param allocation Position and size to be allocated to @a widget .
@@ -603,7 +582,7 @@ public:
    * Even when you you aren't using Gtk::ItemFactory, if you only want to
    * set up accelerators on menu items Gtk::MenuItem::set_accel_path()
    * provides a somewhat more convenient interface.
-   * @param accel_path Path used to look up the accelerator.
+   * @param accel_path Path used to look up the the accelerator.
    * @param accel_group A Gtk::AccelGroup.
    */
   void set_accel_path(const Glib::ustring& accel_path,
@@ -790,17 +769,6 @@ public:
    */
   void set_sensitive(bool sensitive = true);
   
-  /** Sets whether the application intends to draw on the widget in
-   * an ::expose-event handler. 
-   * 
-   * This is a hint to the widget and does not affect the behavior of 
-   * the GTK+ core; many widgets ignore this flag entirely. For widgets 
-   * that do pay attention to the flag, such as Gtk::EventBox and Gtk::Window, 
-   * the effect is to suppress default themed drawing of the widget's 
-   * background. (Children of the widget will still be drawn.) The application 
-   * is then entirely responsible for drawing the widget background.
-   * @param app_paintable <tt>true</tt> if the application will paint on the widget.
-   */
   void set_app_paintable(bool app_paintable = true);
   
   /** Widgets are double buffered by default; you can use this function
@@ -816,18 +784,13 @@ public:
    * In very simple terms, double buffered widgets don't flicker,
    * so you would only use this function to turn off double buffering
    * if you had special needs and really knew what you were doing.
-   * 
-   * @note if you turn off double-buffering, you have to handle
-   * expose events, since even the clearing to the background color or 
-   * pixmap will not happen automatically (as it is done in 
-   * gdk_window_begin_paint()).
    * @param double_buffered <tt>true</tt> to double-buffer a widget.
    */
   void set_double_buffered(bool double_buffered = true);
 
   
-  /** Sets whether the entire widget is queued for drawing when its size 
-   * allocation changes. By default, this setting is <tt>true</tt> and
+  /** Sets whether a when a widgets size allocation changes, the entire
+   * widget is queued for drawing. By default, this setting is <tt>true</tt> and
    * the entire widget is redrawn on every size change. If your widget
    * leaves the upper left unchanged when made bigger, turning this
    * setting on will improve performance.
@@ -1128,7 +1091,7 @@ public:
    * free those resources when the widget is unrealized.
    * @return The Gdk::Screen for the toplevel for this widget.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Gdk::Screen> get_screen();
   
@@ -1142,7 +1105,7 @@ public:
    * free those resources when the widget is unrealized.
    * @return The Gdk::Screen for the toplevel for this widget.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Gdk::Screen> get_screen() const;
 
@@ -1154,7 +1117,7 @@ public:
    * @return <tt>true</tt> if there is a Gdk::Screen associcated
    * with the widget.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool has_screen() const;
 
@@ -1168,7 +1131,7 @@ public:
    * free those resources when the widget is unrealized.
    * @return The Gdk::Display for the toplevel for this widget.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Gdk::Display> get_display();
   
@@ -1181,7 +1144,7 @@ public:
    * free those resources when the widget is unrealized.
    * @return The Gdk::Display for the toplevel for this widget.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Gdk::Display> get_display() const;
 
@@ -1196,7 +1159,7 @@ public:
    * and you should free those resources when the widget is unrealized.
    * @return The Gdk::Window root window for the toplevel for this widget.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Gdk::Window> get_root_window();
   
@@ -1210,7 +1173,7 @@ public:
    * and you should free those resources when the widget is unrealized.
    * @return The Gdk::Window root window for the toplevel for this widget.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Gdk::Window> get_root_window() const;
   
@@ -1240,7 +1203,7 @@ public:
    * be created. Once a clipboard object has
    * been created, it is persistent for all time.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Clipboard> get_clipboard(const Glib::ustring& selection);
   
@@ -1258,32 +1221,15 @@ public:
    * be created. Once a clipboard object has
    * been created, it is persistent for all time.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Clipboard> get_clipboard(const Glib::ustring& selection) const;
 
   //TODO: This probably needs a special conversion to do an extra ref (take_copy=true) for the returned instance:
   
-  /** Returns the accessible object that describes the widget to an
-   * assistive technology. 
-   * 
-   * If no accessibility library is loaded (i.e. no ATK implementation library is 
-   * loaded via &lt;envar&gt;GTK_MODULES&lt;/envar&gt; or via another application library, 
-   * such as libgnome), then this Atk::Object instance may be a no-op. Likewise, 
-   * if no class-specific Atk::Object implementation is available for the widget 
-   * instance in question, it will inherit an Atk::Object implementation from the 
-   * first ancestor class for which such an implementation is defined.
-   * 
-   * The documentation of the ATK
-   * library contains more information about accessible objects and their uses.
-   * @return The Atk::Object associated with @a widget .
-   */
-
-#ifdef  GTKMM_ATKMM_ENABLED
   Glib::RefPtr<Atk::Object> get_accessible();
-#endif //  GTKMM_ATKMM_ENABLED
-
 
+  
   /** Sets the colormap for the widget to the given value. Widget must not
    * have been previously realized. This probably should only be used
    * from an <tt>init()</tt> function (i.e. from the constructor 
@@ -1576,7 +1522,7 @@ public:
 
   
   /** A convenience function that uses the theme engine and RC file
-   * settings for the widget to look up @a stock_id  and render it to
+   * settings for @a widget  to look up @a stock_id  and render it to
    * a pixbuf. @a stock_id  should be a stock icon ID such as
    * Gtk::STOCK_OPEN or Gtk::STOCK_OK. @a size  should be a size
    * such as Gtk::ICON_SIZE_MENU. @a detail  should be a string that
@@ -1591,7 +1537,7 @@ public:
    * the size of the source and don't scale (if there are multiple 
    * source sizes, GTK+ picks one of the available sizes).
    * @param detail Render detail to pass to theme engine.
-   * @return A new pixbuf if the stock ID was known.
+   * @return A new pixbuf, or <tt>0</tt> if the stock ID wasn't known.
    */
   Glib::RefPtr<Gdk::Pixbuf> render_icon(const StockID& stock_id, IconSize size, const Glib::ustring& detail = Glib::ustring());
 
@@ -1734,9 +1680,6 @@ public:
    */
   void shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y);
   void unset_shape_combine_mask();
-  
-  void input_shape_combine_mask(const Glib::RefPtr<const Gdk::Bitmap>& shape_mask, int offset_x, int offset_y);
-  void unset_input_shape_combine_mask();
 
 
   // must be realized 
@@ -1764,7 +1707,7 @@ public:
    * @return The list of mnemonic labels; free this list
    * with Glib::list_free() when you are done with it.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ListHandle<Widget*> list_mnemonic_labels();
  
@@ -1781,7 +1724,7 @@ public:
    * @return The list of mnemonic labels; free this list
    * with Glib::list_free() when you are done with it.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   Glib::ListHandle<const Widget*> list_mnemonic_labels() const;
  
@@ -1789,9 +1732,10 @@ public:
    * this widget. (See list_mnemonic_labels()). Note the
    * list of mnemonic labels for the widget is cleared when the
    * widget is destroyed, so the caller must make sure to update
-   * its internal state at this point as well.
+   * it's internal state at this point as well, by using a connection
+   * to the ::destroy signal or a weak notifier.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param label A Gtk::Widget that acts as a mnemonic label for @a widget .
    */
   void add_mnemonic_label(Widget& label);
@@ -1801,7 +1745,7 @@ public:
    * must have previously been added to the list with
    * add_mnemonic_label().
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param label A Gtk::Widget that was previously set as a mnemnic label for
    *  @a widget  with add_mnemonic_label().
    */
@@ -1865,7 +1809,7 @@ public:
    * use gtk_target_list_add_text_targets() and
    * gtk_drag_dest_set_target_list().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param widget A Gtk::Widget that's a drag destination.
    */
   void drag_dest_add_text_targets();  
@@ -1876,7 +1820,7 @@ public:
    * use gtk_target_list_add_image_targets() and
    * gtk_drag_dest_set_target_list().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param widget A Gtk::Widget that's a drag destination.
    */
   void drag_dest_add_image_targets();
@@ -1887,7 +1831,7 @@ public:
    * use gtk_target_list_add_uri_targets() and
    * gtk_drag_dest_set_target_list().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param widget A Gtk::Widget that's a drag destination.
    */
   void drag_dest_add_uri_targets();
@@ -1920,15 +1864,6 @@ public:
    * @param stock_id The ID of the stock icon to use.
    */
   void drag_source_set_icon(const StockID& stock_id);
-  
-  /** Sets the icon that will be used for drags from a particular source
-   * to a themed icon. See the docs for Gtk::IconTheme for more details.
-   * 
-   * @newin2p8
-   * @param widget A Gtk::Widget.
-   * @param icon_name Name of icon to use.
-   */
-  void drag_source_set_icon(const Glib::ustring& icon_name);
 
   
   /** Add the text targets supported by Gtk::Selection to
@@ -1937,7 +1872,7 @@ public:
    * use gtk_target_list_add_text_targets() and
    * gtk_drag_source_set_target_list().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param widget A Gtk::Widget that's is a drag source.
    */
   void drag_source_add_text_targets();
@@ -1948,7 +1883,7 @@ public:
    * use gtk_target_list_add_uri_targets() and
    * gtk_drag_source_set_target_list().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param widget A Gtk::Widget that's is a drag source.
    */
   void drag_source_add_uri_targets();
@@ -1959,7 +1894,7 @@ public:
    * use gtk_target_list_add_image_targets() and
    * gtk_drag_source_set_target_list().
    * 
-   * @newin2p6
+   * Since: 2.6
    * @param widget A Gtk::Widget that's is a drag source.
    */
   void drag_source_add_image_targets();
@@ -1998,7 +1933,7 @@ public:
   /** This function works like queue_resize(), except that the
    * widget is not invalidated.
    * 
-   * @newin2p4
+   * Since: 2.4
    */
   void queue_resize_no_redraw();
   
@@ -2007,7 +1942,7 @@ public:
    * will affect this widget.
    * @return The current value of the "no_show_all" property.
    * 
-   * @newin2p4.
+   * Since: 2.4.
    */
   bool get_no_show_all() const;
   
@@ -2017,7 +1952,7 @@ public:
    * This is mostly for use in constructing widget hierarchies with externally
    * controlled visibility, see Gtk::UIManager.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param no_show_all The new value for the "no_show_all" property.
    */
   void set_no_show_all(bool no_show_all = true);
@@ -2039,20 +1974,6 @@ public:
    */
   void unparent();
 
-  //TODO: When exactly do we need to custom containers need to call map() on the child widgets?
-  //Most containers that derive from GtkContainer do not need to, but GtkNotebook does.
-  
-  /** This function is only for use in widget implementations. Causes
-   * a widget to be mapped if it isn't already.
-   */
-  void map();
-  
-  /** This function is only for use in widget implementations. Causes
-   * a widget to be unmapped if it's currently mapped.
-   */
-  void unmap();
-
-  //TODO: The drawable should be passed by reference, when we can break API/ABI, but it's not the end of the world. murrayc.
   void draw_insertion_cursor(Glib::RefPtr<Gdk::Drawable> drawable, const Gdk::Rectangle& area, const Gdk::Rectangle& location, bool is_primary, TextDirection direction, bool draw_arrow = true);
   
          
@@ -2102,56 +2023,29 @@ public:
   int get_width() const;
   int get_height() const;
 
-  
-  bool is_composited() const;
-
-  //From gtkaction.h:
-  
-  Glib::RefPtr<Action> get_action();
-  
-  Glib::RefPtr<const Action> get_action() const;
-
-   Gtk::StateType get_state() const;
-    Gtk::StateType get_saved_state() const;
-    Requisition get_requisition() const;
-    Allocation get_allocation() const;
-    Glib::RefPtr<Gdk::Window> get_window();
+  Gtk::StateType get_state() const;
+  Gtk::StateType get_saved_state() const;
+  Requisition get_requisition() const;
+  Allocation get_allocation() const;
+  Glib::RefPtr<Gdk::Window> get_window();
   Glib::RefPtr<const Gdk::Window> get_window() const;
- 
 
-/**
-   * @par Prototype:
-   * <tt>void %show()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_show();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %hide()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_hide();
 
 
   //: Emitted on mapping of a widget to the screen.
   //- See {flags.mapped}.
   
-/**
-   * @par Prototype:
-   * <tt>void %map()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_map();
 
 
   //- See {flags.mapped}.
   
-/**
-   * @par Prototype:
-   * <tt>void %unmap()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_unmap();
 
@@ -2162,10 +2056,6 @@ public:
   //- when overriding the impl method, you should call the 
   //- default realize method.
   
-/**
-   * @par Prototype:
-   * <tt>void %realize()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_realize();
 
@@ -2173,27 +2063,13 @@ public:
   //- See {flags.realized}.  This should not be called by the user.
   //__WRAP(meth|sig|impl,void unrealize_(),gtk_widget_unrealize,"unrealize")
   
-/**
-   * @par Prototype:
-   * <tt>void %unrealize()</tt>
-   */
 
   Glib::SignalProxy0< void > signal_unrealize();
 
 
-/**
-   * @par Prototype:
-   * <tt>void %size_request(Requisition* requisition)</tt>
-   */
-
   Glib::SignalProxy1< void,Requisition* > signal_size_request();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %size_allocate(Allocation& allocation)</tt>
-   */
-
   Glib::SignalProxy1< void,Allocation& > signal_size_allocate();
 
 
@@ -2202,11 +2078,9 @@ public:
 //  and      style_set  => style_changed 
 //  to avoid confusion with set_parent and set_style.
 
+  //: Informs objects that their state has changed.
+  //- The old state is passed as the argument.
   
-/**
-   * @par Prototype:
-   * <tt>void %state_changed(Gtk::StateType previous_state)</tt>
-   */
 
   Glib::SignalProxy1< void,Gtk::StateType > signal_state_changed();
 
@@ -2215,162 +2089,71 @@ public:
   //- The widget passed is the former parent, which may be 0 if 
   //- there was no parent. (was parent_set in GTK+)
   
-/**
-   * @par Prototype:
-   * <tt>void %parent_changed(Widget* previous_parent)</tt>
-   */
 
   Glib::SignalProxy1< void,Widget* > signal_parent_changed();
 
 
-/**
-   * @par Prototype:
-   * <tt>void %hierarchy_changed(Widget* previous_toplevel)</tt>
-   */
-
   Glib::SignalProxy1< void,Widget* > signal_hierarchy_changed();
 
 
-  /** The style-set signal is emitted when a new style has been set 
-   * on a widget. Note that style-modifying functions like 
-   * modify_base() also cause this signal to be emitted.
-   *
-   * @param previous_style  the previous style, or an empty RefPtr if the widget 
-   * just got its initial style. 
-   */
+  //: Informs objects that their style has been changed.
+  //- The former style is passed as the argument. (was style_set in gtk+)
   
-/**
-   * @par Prototype:
-   * <tt>void %style_changed(const Glib::RefPtr<Style>& previous_style)</tt>
-   */
 
   Glib::SignalProxy1< void,const Glib::RefPtr<Style>& > signal_style_changed();
 
 
-/**
-   * @par Prototype:
-   * <tt>void %direction_changed(TextDirection direction)</tt>
-   */
-
   Glib::SignalProxy1< void,TextDirection > signal_direction_changed();
 
 
-/**
-   * @par Prototype:
-   * <tt>void %grab_notify(bool was_grabbed)</tt>
-   */
-
   Glib::SignalProxy1< void,bool > signal_grab_notify();
 
 
- /** The ::child-notify signal is emitted for each child property that has 
-  * changed on an object. The signal's detail holds the property name. 
-  *
-  * @param pspec The GParamSpec of the changed child property.
-  */
-  
-/**
-   * @par Prototype:
-   * <tt>void %child_notify(GParamSpec* pspec)</tt>
-   */
-
   Glib::SignalProxy1< void,GParamSpec* > signal_child_notify();
 
 
   //_WRAP_SIGNAL(void add_accelerator(guint, GtkAccelGroup*, guint accel_key, Gdk::ModifierType, AccelFlags), "add-accelerator")
   //_WRAP_SIGNAL(void remove_accelerator(GtkAccelGroup* accel_group, guint, Gdk::ModifierType), "remove-accelerator")
   
-/**
-   * @par Prototype:
-   * <tt>bool %mnemonic_activate(bool group_cycling)</tt>
-   */
 
   Glib::SignalProxy1< bool,bool > signal_mnemonic_activate();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %grab_focus()</tt>
-   */
-
   Glib::SignalProxy0< void > signal_grab_focus();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %focus(DirectionType direction)</tt>
-   */
-
   Glib::SignalProxy1< bool,DirectionType > signal_focus();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %event(GdkEvent* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEvent* > signal_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %event_after(GdkEvent* event)</tt>
-   */
-
   Glib::SignalProxy1< void,GdkEvent* > signal_event_after();
 
 
   //: Event triggered by user pressing button.
   
-/**
-   * @par Prototype:
-   * <tt>bool %button_press_event(GdkEventButton* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventButton* > signal_button_press_event();
 
 
   //: Event triggered by user releasing button.
   
-/**
-   * @par Prototype:
-   * <tt>bool %button_release_event(GdkEventButton* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventButton* > signal_button_release_event();
 
 
-/**
-   * @par Prototype:
-   * <tt>bool %scroll_event(GdkEventScroll* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventScroll* > signal_scroll_event();
 
 
   //: Event triggered by user moving pointer.
   
-/**
-   * @par Prototype:
-   * <tt>bool %motion_notify_event(GdkEventMotion* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventMotion* > signal_motion_notify_event();
 
 
- /** The delete_event signal is emitted if a user requests that
-  * a toplevel window is closed. The default handler for this signal
-  * hides the window.
-  *
-  * @param event the event which triggered this signal.
-  * @result true to stop other handlers from being invoked for the event, 
-  * or false to propagate the event. further.
-  */
+  //: Event triggered by window being closed.
   
-/**
-   * @par Prototype:
-   * <tt>bool %delete_event(GdkEventAny* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventAny* > signal_delete_event();
 
@@ -2385,406 +2168,139 @@ public:
   //- even indicated.  This is important for things such as 
   //- Gtk::DrawingArea. 
   
-/**
-   * @par Prototype:
-   * <tt>bool %expose_event(GdkEventExpose* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventExpose* > signal_expose_event();
 
 
   //: Event triggered by a key press will widget has focus.
   
-/**
-   * @par Prototype:
-   * <tt>bool %key_press_event(GdkEventKey* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventKey* > signal_key_press_event();
 
 
   //: Event triggered by a key release will widget has focus.
   
-/**
-   * @par Prototype:
-   * <tt>bool %key_release_event(GdkEventKey* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventKey* > signal_key_release_event();
 
 
   //: Event triggered by pointer entering widget area.
   
-/**
-   * @par Prototype:
-   * <tt>bool %enter_notify_event(GdkEventCrossing* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventCrossing* > signal_enter_notify_event();
 
 
   //: Event triggered by pointer leaving widget area.
   
-/**
-   * @par Prototype:
-   * <tt>bool %leave_notify_event(GdkEventCrossing* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventCrossing* > signal_leave_notify_event();
 
  
   //: Event triggered by a window resizing.
   
-/**
-   * @par Prototype:
-   * <tt>bool %configure_event(GdkEventConfigure* event)</tt>
-   */
 
   Glib::SignalProxy1< bool,GdkEventConfigure* > signal_configure_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %focus_in_event(GdkEventFocus* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventFocus* > signal_focus_in_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %focus_out_event(GdkEventFocus* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventFocus* > signal_focus_out_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %map_event(GdkEventAny* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventAny* > signal_map_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %unmap_event(GdkEventAny* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventAny* > signal_unmap_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %property_notify_event(GdkEventProperty* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventProperty* > signal_property_notify_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %selection_clear_event(GdkEventSelection* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_clear_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %selection_request_event(GdkEventSelection* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_request_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %selection_notify_event(GdkEventSelection* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventSelection* > signal_selection_notify_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %proximity_in_event(GdkEventProximity* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventProximity* > signal_proximity_in_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %proximity_out_event(GdkEventProximity* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventProximity* > signal_proximity_out_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %visibility_notify_event(GdkEventVisibility* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventVisibility* > signal_visibility_notify_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %client_event(GdkEventClient* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventClient* > signal_client_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %no_expose_event(GdkEventAny* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventAny* > signal_no_expose_event();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %window_state_event(GdkEventWindowState* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEventWindowState* > signal_window_state_event();
 
 
   //We use the optional custom_c_callback parameter with _WRAP_SIGNAL() for some of these,
-  //so that we can write special code to wrap the non-const SelectionData& output parameters:
+  //so that we can write special code to wrap the non-const SelectioData& output parameters:
   
-/**
-   * @par Prototype:
-   * <tt>void %selection_get(SelectionData& selection_data, guint info, guint time)</tt>
-   */
 
   Glib::SignalProxy3< void,SelectionData&,guint,guint > signal_selection_get();
 
   
-/**
-   * @par Prototype:
-   * <tt>void %selection_received(const SelectionData& selection_data, guint time)</tt>
-   */
-
   Glib::SignalProxy2< void,const SelectionData&,guint > signal_selection_received();
 
   
-  /** THe drag_begin signal is emitted on the drag source when a drag is started. 
-   * A typical reason to connect to this signal is to set up a custom drag icon with
-   * drag_source_set_icon().
-   *
-   * @param context the drag context
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_begin();
 
   
-  /** The drag_end signal is emitted on the drag source when a drag is finished. 
-   * A typical reason to connect to this signal is to undo things done in the drag-begin 
-   * signal handler.
-   *
-   * @param context the drag context.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %drag_end(const Glib::RefPtr<Gdk::DragContext>& context)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_end();
 
 
-  /** The drag_data_get signal is emitted on the drag source when the drop site requests
-   * the data which is dragged. It is the responsibility of the signal handler to fill @a data
-   * with the data in the format which is indicated by @a info. See SelectionData::set() and 
-   * SelectionData::set_text().
-   *
-   * @param context: the drag context.
-   * @param selection_data the SelectionData to be filled with the dragged data.
-   * @param info the info that has been registered with the target in the TargetList.
-   * @param time the timestamp at which the data was requested.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, SelectionData& selection_data, guint info, guint time)</tt>
-   */
-
   Glib::SignalProxy4< void,const Glib::RefPtr<Gdk::DragContext>&,SelectionData&,guint,guint > signal_drag_data_get();
 
   
-  /**  The drag_data_delete signal is emitted on the drag source when a drag with the action
-   * Gdk::ACTION_MOVE is successfully completed. The signal handler is responsible for deleting
-   * the data that has been dropped. What "delete" means, depends on the context of the drag
-   * operation. 
-   *
-   * @param context the drag context.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %drag_data_delete(const Glib::RefPtr<Gdk::DragContext>& context)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::DragContext>& > signal_drag_data_delete();
 
   
-  /**  The drag_leave signal is emitted on the drop site when the cursor leaves the widget.
-   * A typical reason to connect to this signal is to undo things done in the drag_motion signal handler, 
-   *  e.g. undo highlighting with drag_unhighlight().
-   *
-   * @param context the drag context.
-   * @param time the timestamp of the motion event.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time)</tt>
-   */
-
   Glib::SignalProxy2< void,const Glib::RefPtr<Gdk::DragContext>&,guint > signal_drag_leave();
 
   
-  /** The drag_motion signal is emitted on the drop site when the user moves the cursor over
-   * the widget during a drag. The signal handler must determine whether the cursor position is in 
-   * a drop zone or not. If it is not in a drop zone, it returns false and no further processing is
-   * necessary. Otherwise, the handler returns true. In this case, the handler is responsible for
-   * providing the necessary information for displaying feedback to the user, by calling
-   * drag_status(). If the decision whether the drop will be accepted or rejected can't be made
-   * based solely on the cursor position and the type of the data, the handler may inspect the dragged 
-   * data by calling drag_get_data() and defer the drag_status() call to the drag_data_received 
-   * handler. 
-   *
-   * Note that there is no drag_enter signal. The drag receiver has to keep track of whether
-   * he has received any drag_motion signals since the last drag_leave and if not, treat the
-   * drag_motion signal as an "enter" signal. Upon an "enter", the handler will typically highlight 
-   * the drop site with drag_highlight().
-   * 
-   * @param context the drag context.
-   * @param x the x coordinate of the current cursor position.
-   * @param y the y coordinate of the current cursor position.
-   * @param time the timestamp of the motion event.
-   * @result whether the cursor position is in a drop zone.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>bool %drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)</tt>
-   */
-
   Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > signal_drag_motion();
 
   
-  /** The drag_drop signal is emitted on the drop site when the user drops the data
-   * onto the widget. The signal handler must determine whether the cursor position is in 
-   * a drop zone or not. If it is not in a drop zone, it returns false and no further 
-   * processing is necessary. Otherwise, the handler returns true. In this case, the handler 
-   * must ensure that gtk_drag_finish() is called to let the source know that the drop is done.
-   * The call to gtk_drag_finish() can be done either directly or in a drag_data_received handler
-   * which gets triggered by calling drop_get_data() to receive the data for one or more of the 
-   * supported targets.
-   *
-   * @param context the drag context.
-   * @param x the x coordinate of the current cursor position.
-   * @param y the y coordinate of the current cursor position.
-   * @param time: the timestamp of the motion event.
-   * @result whether the cursor position is in a drop zone
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>bool %drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)</tt>
-   */
-
   Glib::SignalProxy4< bool,const Glib::RefPtr<Gdk::DragContext>&,int,int,guint > signal_drag_drop();
 
   
-  /** The drag_data_received signal is emitted on the drop site when the dragged data has been 
-   * received. If the data was received in order to determine whether the drop will be accepted, 
-   * the handler is expected to call drag_status() and <emphasis>not</emphasis> finish the drag. 
-   * If the data was received in response to a drag_drop signal (and this is the last target to be 
-   * received), the handler for this signal is expected to process the received data and then call 
-   * drag_finish(), setting the @a success parameter depending on whether the data was processed 
-   * successfully.
-   *
-   * The handler may inspect and modify @drag_context->action before calling gtk_drag_finish(), 
-   * e.g. to implement %Gdk::ACTION_ASK.
-   *
-   * @param drag_context the drag context
-   * @param x where the drop happened
-   * @param y where the drop happened
-   * @param data the received data
-   * @param info the info that has been registered with the target in the TargetList.
-   * @param time the timestamp at which the data was received.
-   */
-  
-/**
-   * @par Prototype:
-   * <tt>void %drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const SelectionData& selection_data, guint info, guint time)</tt>
-   */
-
   Glib::SignalProxy6< void,const Glib::RefPtr<Gdk::DragContext>&,int,int,const SelectionData&,guint,guint > signal_drag_data_received();
 
 
-  //Note that the deprecated keyword has no effect on _WRAP_SIGNAL() yet.
-  //It doesn't seem like a good idea to put virtual functions in #ifdefs, because that would change the size of the class instances.
-  /** @deprecated This should never have been in the API. It was never meaningful.
-   */
+  //accessibility signals:
   
-/**
-   * @par Prototype:
-   * <tt>Glib::RefPtr<Atk::Object> %get_accessible()</tt>
-   */
 
-#ifdef GTKMM_ATKMM_ENABLED
   Glib::SignalProxy0< Glib::RefPtr<Atk::Object> > signal_get_accessible();
-#endif // GTKMM_ATKMM_ENABLED
 
   
-/**
-   * @par Prototype:
-   * <tt>void %screen_changed(const Glib::RefPtr<Gdk::Screen>& previous_screen)</tt>
-   */
-
   Glib::SignalProxy1< void,const Glib::RefPtr<Gdk::Screen>& > signal_screen_changed();
 
 
-/**
-   * @par Prototype:
-   * <tt>void %composited_changed()</tt>
-   */
-
-  Glib::SignalProxy0< void > signal_composited_changed();
-
-
 //TODO: The signal_id is very C-like here:                                                                          
   //_WRAP_SIGNAL(bool can_activate_accel(guint signal_id), "can_activate_accel")
   
   //Keybinding signals:
-   //TODO: This might actually be useful. See the C docs.
   
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The name of the widget.
+  
+  /** The name of the 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<Glib::ustring> property_name() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The name of the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2792,19 +2308,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_name() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The parent widget of this widget. Must be a Container widget.
+  /** The parent widget of this widget. Must be a Container 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<Container*> property_parent() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The parent widget of this widget. Must be a Container widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2812,19 +2324,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Container*> property_parent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Override for width request of the widget
+  /** Override for width request of the 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<int> property_width_request() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Override for width request of the widget
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2832,19 +2340,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_width_request() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Override for height request of the widget
+  /** Override for height request of the 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<int> property_height_request() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Override for height request of the widget
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2852,19 +2356,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_height_request() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the widget is visible.
+  /** Whether the widget is 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<bool> property_visible() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the widget is visible.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2872,19 +2372,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_visible() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the widget responds to input.
+  /** Whether the widget responds to input.
    *
    * 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_sensitive() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the widget responds to input.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2892,19 +2388,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_sensitive() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the application will paint directly on the widget.
+  /** Whether the application will paint directly on the 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<bool> property_app_paintable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the application will paint directly on the widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2912,19 +2404,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_app_paintable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the widget can accept the input focus.
+  /** Whether the widget can accept the input focus.
    *
    * 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_can_focus() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the widget can accept the input focus.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2932,19 +2420,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_can_focus() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the widget has the input focus.
+  /** Whether the widget has the input focus.
    *
    * 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_has_focus() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the widget has the input focus.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2952,19 +2436,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_focus() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the widget can be the default widget.
+  /** Whether the widget can be the default 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<bool> property_can_default() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the widget can be the default widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2972,19 +2452,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_can_default() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the widget is the default widget.
+  /** Whether the widget is the default 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<bool> property_has_default() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the widget is the default widget.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -2992,19 +2468,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_has_default() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
+  /** If TRUE
    *
    * 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_receives_default() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -3012,30 +2484,24 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_receives_default() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the widget is part of a composite widget.
+  /** Whether the widget is part of a composite 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<bool> property_composite_child() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The style of the widget
+  /** The style of the 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< Glib::RefPtr<Style> > property_style() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The style of the widget
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -3043,19 +2509,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Style> > property_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The event mask that decides what kind of GdkEvents this widget gets.
+  /** The event mask that decides what kind of GdkEvents this widget gets.
    *
    * 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::EventMask> property_events() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The event mask that decides what kind of GdkEvents this widget gets.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -3063,19 +2525,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::EventMask> property_events() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The mask that decides what kind of extension events this widget gets.
+  /** The mask that decides what kind of extension events this widget gets.
    *
    * 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::ExtensionMode> property_extension_events() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The mask that decides what kind of extension events this widget gets.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -3083,38 +2541,32 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::ExtensionMode> property_extension_events() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
   //comment in GTK+ header: "seldomly overidden"
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void dispatch_child_properties_changed_vfunc(guint p1, GParamSpec** p2);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void show_all_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void hide_all_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void dispatch_child_properties_changed_vfunc(guint p1, GParamSpec** p2);
 
-  #ifdef GLIBMM_VFUNCS_ENABLED
+    virtual void show_all_vfunc();
+    virtual void hide_all_vfunc();
 
-#ifdef  GTKMM_ATKMM_ENABLED
-  virtual Glib::RefPtr<Atk::Object> get_accessible_vfunc();
-
-#endif //  GTKMM_ATKMM_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
+    virtual Glib::RefPtr<Atk::Object> get_accessible_vfunc();
 
 
 protected:
   Widget();
 
   
+  /** This function is only for use in widget implementations. Causes
+   * a widget to be mapped if it isn't already.
+   */
+  void map();
+  
+  /** This function is only for use in widget implementations. Causes
+   * a widget to be unmapped if it's currently mapped.
+   */
+  void unmap();
+  
   /** Creates the GDK (windowing system) resources associated with a
    * widget.  For example, @a widget -&gt;window will be created when a widget
    * is realized.  Normally realization happens implicitly; if you show
@@ -3175,9 +2627,9 @@ protected:
 
   void realize_if_needed();
 
-   void set_allocation(const Allocation& value);
-    void set_window(const Glib::RefPtr<Gdk::Window>& value);
- 
+  void set_allocation(const Allocation& value);
+  void set_window(const Glib::RefPtr<Gdk::Window>& value);
+
 
 };
 
@@ -3209,8 +2661,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gtk::Widget* wrap(GtkWidget* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _GTKMM_WIDGET_H */
 
diff --git a/libs/gtkmm2/gtk/gtkmm/window.cc b/libs/gtkmm2/gtk/gtkmm/window.cc
index 6da98aec21..4be33fd86b 100644
--- a/libs/gtkmm2/gtk/gtkmm/window.cc
+++ b/libs/gtkmm2/gtk/gtkmm/window.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <gtkmm/window.h>
 #include <gtkmm/private/window_p.h>
 
@@ -124,7 +123,7 @@ void Window::_destroy_c_instance()
     //Glib::Object::~Object() will not g_object_unref() it too. because gobject_ is now 0.
   }
 }
-
+ 
 void Window_Class::dispose_vfunc_callback(GObject* self)
 {
   //Avoid disposal of Windows on delete_event (window close) signal.
@@ -213,8 +212,7 @@ void Window::unset_default()
 namespace
 {
 
-
-static void Window_signal_set_focus_callback(GtkWindow* self, GtkWidget* p0,void* data)
+void Window_signal_set_focus_callback(GtkWindow* self, GtkWidget* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,Widget* > SlotType;
@@ -222,24 +220,20 @@ static void Window_signal_set_focus_callback(GtkWindow* self, GtkWidget* p0,void
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Window_signal_set_focus_info =
+const Glib::SignalProxyInfo Window_signal_set_focus_info =
 {
   "set_focus",
   (GCallback) &Window_signal_set_focus_callback,
@@ -247,7 +241,7 @@ static const Glib::SignalProxyInfo Window_signal_set_focus_info =
 };
 
 
-static gboolean Window_signal_frame_event_callback(GtkWindow* self, GdkEvent* p0,void* data)
+gboolean Window_signal_frame_event_callback(GtkWindow* self, GdkEvent* p0,void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< bool,GdkEvent* > SlotType;
@@ -255,26 +249,22 @@ static gboolean Window_signal_frame_event_callback(GtkWindow* self, GdkEvent* p0
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Window_signal_frame_event_notify_callback(GtkWindow* self, GdkEvent* p0, void* data)
+gboolean Window_signal_frame_event_notify_callback(GtkWindow* self, GdkEvent* p0, void* data)
 {
   using namespace Gtk;
   typedef sigc::slot< void,GdkEvent* > SlotType;
@@ -282,169 +272,34 @@ static gboolean Window_signal_frame_event_notify_callback(GtkWindow* self, GdkEv
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Window_signal_frame_event_info =
+const Glib::SignalProxyInfo Window_signal_frame_event_info =
 {
   "frame_event",
   (GCallback) &Window_signal_frame_event_callback,
   (GCallback) &Window_signal_frame_event_notify_callback
 };
 
-
 } // anonymous namespace
 
 
 namespace Glib
 {
 
-Glib::RefPtr<Gtk::WindowGroup> wrap(GtkWindowGroup* object, bool take_copy)
-{
-  return Glib::RefPtr<Gtk::WindowGroup>( dynamic_cast<Gtk::WindowGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gtk
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& WindowGroup_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_ = &WindowGroup_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(gtk_window_group_get_type());
-
-    // Add derived versions of interfaces, if the C type implements any interfaces:
-  }
-
-  return *this;
-}
-
-void WindowGroup_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);
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* WindowGroup_Class::wrap_new(GObject* object)
-{
-  return new WindowGroup((GtkWindowGroup*)object);
-}
-
-
-/* The implementation: */
-
-GtkWindowGroup* WindowGroup::gobj_copy()
-{
-  reference();
-  return gobj();
-}
-
-WindowGroup::WindowGroup(const Glib::ConstructParams& construct_params)
-:
-  Glib::Object(construct_params)
-{}
-
-WindowGroup::WindowGroup(GtkWindowGroup* castitem)
-:
-  Glib::Object((GObject*)(castitem))
-{}
-
-WindowGroup::~WindowGroup()
-{}
-
-
-WindowGroup::CppClassType WindowGroup::windowgroup_class_; // initialize static member
-
-GType WindowGroup::get_type()
-{
-  return windowgroup_class_.init().get_type();
-}
-
-GType WindowGroup::get_base_type()
-{
-  return gtk_window_group_get_type();
-}
-
-
-WindowGroup::WindowGroup()
-:
-  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
-  Glib::Object(Glib::ConstructParams(windowgroup_class_.init()))
-{
-  }
-
-Glib::RefPtr<WindowGroup> WindowGroup::create()
-{
-  return Glib::RefPtr<WindowGroup>( new WindowGroup() );
-}
-void WindowGroup::add_window(Window& window)
-{
-gtk_window_group_add_window(gobj(), (window).gobj()); 
-}
-
-void WindowGroup::remove_window(Window& window)
-{
-gtk_window_group_remove_window(gobj(), (window).gobj()); 
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Gtk
-
-
-namespace Glib
-{
-
 Gtk::Window* wrap(GtkWindow* object, bool take_copy)
 {
   return dynamic_cast<Gtk::Window *> (Glib::wrap_auto ((GObject*)(object), take_copy));
@@ -483,22 +338,12 @@ void Window_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED //We always need dispose_vfunc_callback
     reinterpret_cast<GObjectClass*>(klass)->dispose = &dispose_vfunc_callback;
-#ifdef GLIBMM_VFUNCS_ENABLED
-  #endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  klass->set_focus = &set_focus_callback;
+    klass->set_focus = &set_focus_callback;
   klass->frame_event = &frame_event_callback;
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Window_Class::set_focus_callback(GtkWindow* self, GtkWidget* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -511,20 +356,16 @@ void Window_Class::set_focus_callback(GtkWindow* self, GtkWidget* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_set_focus(Glib::wrap(p0)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -537,6 +378,7 @@ void Window_Class::set_focus_callback(GtkWindow* self, GtkWidget* p0)
       (*base->set_focus)(self, p0);
   }
 }
+
 gboolean Window_Class::frame_event_callback(GtkWindow* self, GdkEvent* p0)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -549,19 +391,15 @@ gboolean Window_Class::frame_event_callback(GtkWindow* self, GdkEvent* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_frame_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -577,7 +415,6 @@ gboolean Window_Class::frame_event_callback(GtkWindow* self, GdkEvent* p0)
   typedef gboolean RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 Glib::ObjectBase* Window_Class::wrap_new(GObject* o)
@@ -618,6 +455,7 @@ GType Window::get_base_type()
   return gtk_window_get_type();
 }
 
+
 Window::Window(WindowType type)
 :
   Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
@@ -625,12 +463,12 @@ Window::Window(WindowType type)
 {
   }
 
- WindowType Window::get_window_type() const
+WindowType Window::get_window_type() const
 {
   return static_cast<WindowType>(gobj()->type);
 }
- 
- Glib::RefPtr<Gdk::Window> Window::get_frame()
+
+Glib::RefPtr<Gdk::Window> Window::get_frame()
 {
   Glib::RefPtr<Gdk::Window> ref_ptr(Glib::wrap((GdkWindowObject*)(gobj()->frame)));
 
@@ -649,10 +487,10 @@ Glib::RefPtr<const Gdk::Window> Window::get_frame() const
 
   return ref_ptr;
 }
- 
+
 void Window::set_title(const Glib::ustring& title)
 {
-gtk_window_set_title(gobj(), title.c_str()); 
+  gtk_window_set_title(gobj(), title.c_str());
 }
 
 Glib::ustring Window::get_title() const
@@ -662,12 +500,12 @@ Glib::ustring Window::get_title() const
 
 void Window::set_wmclass(const Glib::ustring& wmclass_name, const Glib::ustring& wmclass_class)
 {
-gtk_window_set_wmclass(gobj(), wmclass_name.c_str(), wmclass_class.c_str()); 
+  gtk_window_set_wmclass(gobj(), wmclass_name.c_str(), wmclass_class.c_str());
 }
 
 void Window::set_role(const Glib::ustring& role)
 {
-gtk_window_set_role(gobj(), role.c_str()); 
+  gtk_window_set_role(gobj(), role.c_str());
 }
 
 Glib::ustring Window::get_role() const
@@ -677,17 +515,17 @@ Glib::ustring Window::get_role() const
 
 void Window::add_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
 {
-gtk_window_add_accel_group(gobj(), Glib::unwrap(accel_group)); 
+  gtk_window_add_accel_group(gobj(), Glib::unwrap(accel_group));
 }
 
 void Window::remove_accel_group(const Glib::RefPtr<AccelGroup>& accel_group)
 {
-gtk_window_remove_accel_group(gobj(), Glib::unwrap(accel_group)); 
+  gtk_window_remove_accel_group(gobj(), Glib::unwrap(accel_group));
 }
 
 void Window::set_position(WindowPosition position)
 {
-gtk_window_set_position(gobj(), ((GtkWindowPosition)(position))); 
+  gtk_window_set_position(gobj(), ((GtkWindowPosition)(position)));
 }
 
 bool Window::activate_focus()
@@ -697,7 +535,7 @@ bool Window::activate_focus()
 
 void Window::set_focus(Gtk::Widget& focus)
 {
-gtk_window_set_focus(gobj(), (focus).gobj()); 
+  gtk_window_set_focus(gobj(), (focus).gobj());
 }
 
 Widget* Window::get_focus()
@@ -707,12 +545,12 @@ Widget* Window::get_focus()
 
 const Widget* Window::get_focus() const
 {
-  return const_cast<Window*>(this)->get_focus();
+  return Glib::wrap(gtk_window_get_focus(const_cast<GtkWindow*>(gobj())));
 }
 
 void Window::set_default(Gtk::Widget& default_widget)
 {
-gtk_window_set_default(gobj(), (default_widget).gobj()); 
+  gtk_window_set_default(gobj(), (default_widget).gobj());
 }
 
 bool Window::activate_default()
@@ -722,7 +560,7 @@ bool Window::activate_default()
 
 void Window::set_transient_for(Window& parent)
 {
-gtk_window_set_transient_for(gobj(), (parent).gobj()); 
+  gtk_window_set_transient_for(gobj(), (parent).gobj());
 }
 
 Window* Window::get_transient_for()
@@ -732,12 +570,12 @@ Window* Window::get_transient_for()
 
 const Window* Window::get_transient_for() const
 {
-  return const_cast<Window*>(this)->get_transient_for();
+  return Glib::wrap(gtk_window_get_transient_for(const_cast<GtkWindow*>(gobj())));
 }
 
 void Window::set_type_hint(Gdk::WindowTypeHint hint)
 {
-gtk_window_set_type_hint(gobj(), ((GdkWindowTypeHint)(hint))); 
+  gtk_window_set_type_hint(gobj(), ((GdkWindowTypeHint)(hint)));
 }
 
 Gdk::WindowTypeHint Window::get_type_hint() const
@@ -747,7 +585,7 @@ Gdk::WindowTypeHint Window::get_type_hint() const
 
 void Window::set_skip_taskbar_hint(bool setting)
 {
-gtk_window_set_skip_taskbar_hint(gobj(), static_cast<int>(setting)); 
+  gtk_window_set_skip_taskbar_hint(gobj(), static_cast<int>(setting));
 }
 
 bool Window::get_skip_taskbar_hint() const
@@ -757,7 +595,7 @@ bool Window::get_skip_taskbar_hint() const
 
 void Window::set_skip_pager_hint(bool setting)
 {
-gtk_window_set_skip_pager_hint(gobj(), static_cast<int>(setting)); 
+  gtk_window_set_skip_pager_hint(gobj(), static_cast<int>(setting));
 }
 
 bool Window::get_skip_pager_hint() const
@@ -765,16 +603,6 @@ bool Window::get_skip_pager_hint() const
   return gtk_window_get_skip_pager_hint(const_cast<GtkWindow*>(gobj()));
 }
 
-void Window::set_urgency_hint(bool setting)
-{
-gtk_window_set_urgency_hint(gobj(), static_cast<int>(setting)); 
-}
-
-bool Window::get_urgency_hint() const
-{
-  return gtk_window_get_urgency_hint(const_cast<GtkWindow*>(gobj()));
-}
-
 bool Window::get_destroy_with_parent() const
 {
   return gtk_window_get_destroy_with_parent(const_cast<GtkWindow*>(gobj()));
@@ -782,7 +610,7 @@ bool Window::get_destroy_with_parent() const
 
 void Window::set_resizable(bool resizable)
 {
-gtk_window_set_resizable(gobj(), static_cast<int>(resizable)); 
+  gtk_window_set_resizable(gobj(), static_cast<int>(resizable));
 }
 
 bool Window::get_resizable() const
@@ -792,7 +620,7 @@ bool Window::get_resizable() const
 
 void Window::set_gravity(Gdk::Gravity gravity)
 {
-gtk_window_set_gravity(gobj(), ((GdkGravity)(gravity))); 
+  gtk_window_set_gravity(gobj(), ((GdkGravity)(gravity)));
 }
 
 Gdk::Gravity Window::get_gravity() const
@@ -802,32 +630,37 @@ Gdk::Gravity Window::get_gravity() const
 
 void Window::set_geometry_hints(Widget& geometry_widget, const Gdk::Geometry& geometry, Gdk::WindowHints geom_mask)
 {
-gtk_window_set_geometry_hints(gobj(), (geometry_widget).gobj(), const_cast<GdkGeometry*>(&(geometry)), ((GdkWindowHints)(geom_mask))); 
+  gtk_window_set_geometry_hints(gobj(), (geometry_widget).gobj(), const_cast<GdkGeometry*>(&(geometry)), ((GdkWindowHints)(geom_mask)));
 }
 
 void Window::set_screen(const Glib::RefPtr<Gdk::Screen>& screen)
 {
-gtk_window_set_screen(gobj(), Glib::unwrap(screen)); 
+  gtk_window_set_screen(gobj(), Glib::unwrap(screen));
 }
 
 Glib::RefPtr<Gdk::Screen> Window::get_screen()
 {
 
   Glib::RefPtr<Gdk::Screen> retvalue = Glib::wrap(gtk_window_get_screen(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Screen> Window::get_screen() const
 {
-  return const_cast<Window*>(this)->get_screen();
+
+  Glib::RefPtr<const Gdk::Screen> retvalue = Glib::wrap(gtk_window_get_screen(const_cast<GtkWindow*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Window::set_has_frame(bool setting)
 {
-gtk_window_set_has_frame(gobj(), static_cast<int>(setting)); 
+  gtk_window_set_has_frame(gobj(), static_cast<int>(setting));
 }
 
 bool Window::get_has_frame() const
@@ -837,17 +670,17 @@ bool Window::get_has_frame() const
 
 void Window::set_frame_dimensions(int left, int top, int right, int bottom)
 {
-gtk_window_set_frame_dimensions(gobj(), left, top, right, bottom); 
+  gtk_window_set_frame_dimensions(gobj(), left, top, right, bottom);
 }
 
 void Window::get_frame_dimensions(int& left, int& top, int& right, int& bottom) const
 {
-gtk_window_get_frame_dimensions(const_cast<GtkWindow*>(gobj()), &left, &top, &right, &bottom); 
+  gtk_window_get_frame_dimensions(const_cast<GtkWindow*>(gobj()), &left, &top, &right, &bottom);
 }
 
 void Window::set_decorated(bool setting)
 {
-gtk_window_set_decorated(gobj(), static_cast<int>(setting)); 
+  gtk_window_set_decorated(gobj(), static_cast<int>(setting));
 }
 
 bool Window::get_decorated() const
@@ -855,16 +688,6 @@ bool Window::get_decorated() const
   return gtk_window_get_decorated(const_cast<GtkWindow*>(gobj()));
 }
 
-void Window::set_deletable(bool setting)
-{
-gtk_window_set_deletable(gobj(), static_cast<int>(setting)); 
-}
-
-bool Window::get_deletable() const
-{
-  return gtk_window_get_deletable(const_cast<GtkWindow*>(gobj()));
-}
-
 Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> > Window::get_icon_list()
 {
   return Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >(gtk_window_get_icon_list(gobj()), Glib::OWNERSHIP_SHALLOW);
@@ -877,91 +700,68 @@ Glib::ListHandle< Glib::RefPtr<const Gdk::Pixbuf> > Window::get_icon_list() cons
 
 void Window::set_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& list)
 {
-gtk_window_set_icon_list(gobj(), list.data()); 
+  gtk_window_set_icon_list(gobj(), list.data());
 }
 
 void Window::set_icon(const Glib::RefPtr<Gdk::Pixbuf>& icon)
 {
-gtk_window_set_icon(gobj(), Glib::unwrap(icon)); 
+  gtk_window_set_icon(gobj(), Glib::unwrap(icon));
 }
 
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 bool Window::set_icon_from_file(const std::string& filename)
-#else
-bool Window::set_icon_from_file(const std::string& filename, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-{
-  GError* gerror = 0;
-  bool retvalue = gtk_window_set_icon_from_file(gobj(), filename.c_str(), &(gerror));
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+{
+  GError *error = 0;
+  bool retvalue = gtk_window_set_icon_from_file(gobj(), filename.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
-
 }
 
 Glib::RefPtr<Gdk::Pixbuf> Window::get_icon()
 {
 
   Glib::RefPtr<Gdk::Pixbuf> retvalue = Glib::wrap(gtk_window_get_icon(gobj()));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const Gdk::Pixbuf> Window::get_icon() const
 {
-  return const_cast<Window*>(this)->get_icon();
+
+  Glib::RefPtr<const Gdk::Pixbuf> retvalue = Glib::wrap(gtk_window_get_icon(const_cast<GtkWindow*>(gobj())));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
 }
 
 void Window::set_default_icon_list(const Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >& list)
 {
-gtk_window_set_default_icon_list(list.data());
+  gtk_window_set_default_icon_list(list.data());
 }
 
-
 Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> > Window::get_default_icon_list()
 {
   return Glib::ListHandle< Glib::RefPtr<Gdk::Pixbuf> >(gtk_window_get_default_icon_list(), Glib::OWNERSHIP_SHALLOW);
 }
 
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
 bool Window::set_default_icon_from_file(const std::string& filename)
-#else
-bool Window::set_default_icon_from_file(const std::string& filename, std::auto_ptr<Glib::Error>& error)
-#endif //GLIBMM_EXCEPTIONS_ENABLED
 {
-  GError* gerror = 0;
-  bool retvalue = gtk_window_set_default_icon_from_file(filename.c_str(), &(gerror));
-
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
-  if(gerror)
-    ::Glib::Error::throw_exception(gerror);
-#else
-  if(gerror)
-    error = ::Glib::Error::throw_exception(gerror);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
+  GError *error = 0;
+  bool retvalue = gtk_window_set_default_icon_from_file(filename.c_str(), &(error));
+  if(error) ::Glib::Error::throw_exception(error);
   return retvalue;
 }
 
-
 void Window::set_auto_startup_notification(bool setting)
 {
-gtk_window_set_auto_startup_notification(static_cast<int>(setting));
+  gtk_window_set_auto_startup_notification(static_cast<int>(setting));
 }
 
-
 void Window::set_modal(bool modal)
 {
-gtk_window_set_modal(gobj(), static_cast<int>(modal)); 
+  gtk_window_set_modal(gobj(), static_cast<int>(modal));
 }
 
 bool Window::get_modal() const
@@ -974,15 +774,14 @@ Glib::ListHandle<Window*> Window::list_toplevels()
   return Glib::ListHandle<Window*>(gtk_window_list_toplevels(), Glib::OWNERSHIP_SHALLOW);
 }
 
-
 void Window::add_mnemonic(guint keyval, Widget& target)
 {
-gtk_window_add_mnemonic(gobj(), keyval, (target).gobj()); 
+  gtk_window_add_mnemonic(gobj(), keyval, (target).gobj());
 }
 
 void Window::remove_mnemonic(guint keyval, Widget& target)
 {
-gtk_window_remove_mnemonic(gobj(), keyval, (target).gobj()); 
+  gtk_window_remove_mnemonic(gobj(), keyval, (target).gobj());
 }
 
 bool Window::mnemonic_activate(guint keyval, Gdk::ModifierType modifier)
@@ -992,7 +791,7 @@ bool Window::mnemonic_activate(guint keyval, Gdk::ModifierType modifier)
 
 void Window::set_mnemonic_modifier(Gdk::ModifierType modifier)
 {
-gtk_window_set_mnemonic_modifier(gobj(), ((GdkModifierType)(modifier))); 
+  gtk_window_set_mnemonic_modifier(gobj(), ((GdkModifierType)(modifier)));
 }
 
 Gdk::ModifierType Window::get_mnemonic_modifier()
@@ -1002,92 +801,87 @@ Gdk::ModifierType Window::get_mnemonic_modifier()
 
 void Window::present()
 {
-gtk_window_present(gobj()); 
-}
-
-void Window::present(guint32 timestamp)
-{
-gtk_window_present_with_time(gobj(), timestamp); 
+  gtk_window_present(gobj());
 }
 
 void Window::iconify()
 {
-gtk_window_iconify(gobj()); 
+  gtk_window_iconify(gobj());
 }
 
 void Window::deiconify()
 {
-gtk_window_deiconify(gobj()); 
+  gtk_window_deiconify(gobj());
 }
 
 void Window::stick()
 {
-gtk_window_stick(gobj()); 
+  gtk_window_stick(gobj());
 }
 
 void Window::unstick()
 {
-gtk_window_unstick(gobj()); 
+  gtk_window_unstick(gobj());
 }
 
 void Window::maximize()
 {
-gtk_window_maximize(gobj()); 
+  gtk_window_maximize(gobj());
 }
 
 void Window::unmaximize()
 {
-gtk_window_unmaximize(gobj()); 
+  gtk_window_unmaximize(gobj());
 }
 
 void Window::fullscreen()
 {
-gtk_window_fullscreen(gobj()); 
+  gtk_window_fullscreen(gobj());
 }
 
 void Window::unfullscreen()
 {
-gtk_window_unfullscreen(gobj()); 
+  gtk_window_unfullscreen(gobj());
 }
 
 void Window::begin_resize_drag(Gdk::WindowEdge edge, int button, int root_x, int root_y, guint32 timestamp)
 {
-gtk_window_begin_resize_drag(gobj(), ((GdkWindowEdge)(edge)), button, root_x, root_y, timestamp); 
+  gtk_window_begin_resize_drag(gobj(), ((GdkWindowEdge)(edge)), button, root_x, root_y, timestamp);
 }
 
 void Window::begin_move_drag(int button, int root_x, int root_y, guint32 timestamp)
 {
-gtk_window_begin_move_drag(gobj(), button, root_x, root_y, timestamp); 
+  gtk_window_begin_move_drag(gobj(), button, root_x, root_y, timestamp);
 }
 
 void Window::set_default_size(int width, int height)
 {
-gtk_window_set_default_size(gobj(), width, height); 
+  gtk_window_set_default_size(gobj(), width, height);
 }
 
 void Window::get_default_size(int& width, int& height) const
 {
-gtk_window_get_default_size(const_cast<GtkWindow*>(gobj()), &width, &height); 
+  gtk_window_get_default_size(const_cast<GtkWindow*>(gobj()), &width, &height);
 }
 
 void Window::resize(int width, int height)
 {
-gtk_window_resize(gobj(), width, height); 
+  gtk_window_resize(gobj(), width, height);
 }
 
 void Window::get_size(int& width, int& height) const
 {
-gtk_window_get_size(const_cast<GtkWindow*>(gobj()), &width, &height); 
+  gtk_window_get_size(const_cast<GtkWindow*>(gobj()), &width, &height);
 }
 
 void Window::move(int x, int y)
 {
-gtk_window_move(gobj(), x, y); 
+  gtk_window_move(gobj(), x, y);
 }
 
 void Window::get_position(int& root_x, int& root_y) const
 {
-gtk_window_get_position(const_cast<GtkWindow*>(gobj()), &root_x, &root_y); 
+  gtk_window_get_position(const_cast<GtkWindow*>(gobj()), &root_x, &root_y);
 }
 
 bool Window::parse_geometry(const Glib::ustring& geometry)
@@ -1095,40 +889,24 @@ bool Window::parse_geometry(const Glib::ustring& geometry)
   return gtk_window_parse_geometry(gobj(), geometry.c_str());
 }
 
-Glib::RefPtr<WindowGroup> Window::get_group()
-{
-
-  Glib::RefPtr<WindowGroup> retvalue = Glib::wrap(gtk_window_get_group(gobj()));
-  if(retvalue)
-    retvalue->reference(); //The function does not do a ref for us.
-  return retvalue;
-
-}
-
-Glib::RefPtr<const WindowGroup> Window::get_group() const
-{
-  return const_cast<Window*>(this)->get_group();
-}
-
 void Window::reshow_with_initial_size()
 {
-gtk_window_reshow_with_initial_size(gobj()); 
+  gtk_window_reshow_with_initial_size(gobj());
 }
 
 void Window::set_default_icon(const Glib::RefPtr<Gdk::Pixbuf>& icon)
 {
-gtk_window_set_default_icon(Glib::unwrap(icon));
+  gtk_window_set_default_icon(Glib::unwrap(icon));
 }
 
-
 void Window::set_keep_above(bool setting)
 {
-gtk_window_set_keep_above(gobj(), static_cast<int>(setting)); 
+  gtk_window_set_keep_above(gobj(), static_cast<int>(setting));
 }
 
 void Window::set_keep_below(bool setting)
 {
-gtk_window_set_keep_below(gobj(), static_cast<int>(setting)); 
+  gtk_window_set_keep_below(gobj(), static_cast<int>(setting));
 }
 
 
@@ -1137,295 +915,193 @@ Glib::SignalProxy1< void,Widget* > Window::signal_set_focus()
   return Glib::SignalProxy1< void,Widget* >(this, &Window_signal_set_focus_info);
 }
 
-
 Glib::SignalProxy1< bool,GdkEvent* > Window::signal_frame_event()
 {
   return Glib::SignalProxy1< bool,GdkEvent* >(this, &Window_signal_frame_event_info);
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Window::property_title() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Window::property_title() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "title");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_allow_shrink() 
 {
   return Glib::PropertyProxy<bool>(this, "allow-shrink");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_allow_shrink() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "allow-shrink");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_allow_grow() 
 {
   return Glib::PropertyProxy<bool>(this, "allow-grow");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_allow_grow() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "allow-grow");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_resizable() 
 {
   return Glib::PropertyProxy<bool>(this, "resizable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_resizable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "resizable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_modal() 
 {
   return Glib::PropertyProxy<bool>(this, "modal");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_modal() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "modal");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<WindowPosition> Window::property_window_position() 
 {
   return Glib::PropertyProxy<WindowPosition>(this, "window-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<WindowPosition> Window::property_window_position() const
 {
   return Glib::PropertyProxy_ReadOnly<WindowPosition>(this, "window-position");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Window::property_default_width() 
 {
   return Glib::PropertyProxy<int>(this, "default-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Window::property_default_width() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "default-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Window::property_default_height() 
 {
   return Glib::PropertyProxy<int>(this, "default-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Window::property_default_height() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "default-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_destroy_with_parent() 
 {
   return Glib::PropertyProxy<bool>(this, "destroy-with-parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_destroy_with_parent() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "destroy-with-parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > Window::property_icon() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "icon");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > Window::property_icon() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "icon");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Screen> > Window::property_screen() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Screen> >(this, "screen");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Screen> > Window::property_screen() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Screen> >(this, "screen");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_is_active() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "is-active");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_has_toplevel_focus() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "has-toplevel-focus");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<GdkWindowTypeHint> Window::property_type_hint() 
 {
   return Glib::PropertyProxy<GdkWindowTypeHint>(this, "type-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<GdkWindowTypeHint> Window::property_type_hint() const
 {
   return Glib::PropertyProxy_ReadOnly<GdkWindowTypeHint>(this, "type-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_skip_taskbar_hint() 
 {
   return Glib::PropertyProxy<bool>(this, "skip-taskbar-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_skip_taskbar_hint() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "skip-taskbar-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_skip_pager_hint() 
 {
   return Glib::PropertyProxy<bool>(this, "skip-pager-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_skip_pager_hint() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "skip-pager-hint");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Window::property_role() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "role");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Window::property_role() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "role");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Window::property_decorated() 
 {
   return Glib::PropertyProxy<bool>(this, "decorated");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Window::property_decorated() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "decorated");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::Gravity> Window::property_gravity() 
 {
   return Glib::PropertyProxy<Gdk::Gravity>(this, "gravity");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Gravity> Window::property_gravity() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Gravity>(this, "gravity");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> Window::property_urgency_hint() 
-{
-  return Glib::PropertyProxy<bool>(this, "urgency-hint");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> Window::property_urgency_hint() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "urgency-hint");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<bool> Window::property_deletable() 
-{
-  return Glib::PropertyProxy<bool>(this, "deletable");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<bool> Window::property_deletable() const
-{
-  return Glib::PropertyProxy_ReadOnly<bool>(this, "deletable");
-}
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 void Gtk::Window::on_set_focus(Widget* focus)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1435,6 +1111,7 @@ void Gtk::Window::on_set_focus(Widget* focus)
   if(base && base->set_focus)
     (*base->set_focus)(gobj(),(GtkWidget*)Glib::unwrap(focus));
 }
+
 bool Gtk::Window::on_frame_event(GdkEvent* event)
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -1447,10 +1124,117 @@ bool Gtk::Window::on_frame_event(GdkEvent* event)
   typedef bool RType;
   return RType();
 }
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
+
+} // namespace Gtk
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gtk::WindowGroup> wrap(GtkWindowGroup* object, bool take_copy)
+{
+  return Glib::RefPtr<Gtk::WindowGroup>( dynamic_cast<Gtk::WindowGroup*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gtk
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& WindowGroup_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_ = &WindowGroup_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(gtk_window_group_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void WindowGroup_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* WindowGroup_Class::wrap_new(GObject* object)
+{
+  return new WindowGroup((GtkWindowGroup*)object);
+}
+
+
+/* The implementation: */
+
+GtkWindowGroup* WindowGroup::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+WindowGroup::WindowGroup(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+WindowGroup::WindowGroup(GtkWindowGroup* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+WindowGroup::~WindowGroup()
+{}
+
+
+WindowGroup::CppClassType WindowGroup::windowgroup_class_; // initialize static member
+
+GType WindowGroup::get_type()
+{
+  return windowgroup_class_.init().get_type();
+}
+
+GType WindowGroup::get_base_type()
+{
+  return gtk_window_group_get_type();
+}
+
+WindowGroup::WindowGroup()
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(windowgroup_class_.init()))
+{
+  }
+
+Glib::RefPtr<WindowGroup> WindowGroup::create()
+{
+  return Glib::RefPtr<WindowGroup>( new WindowGroup() );
+}
+void WindowGroup::add_window(Window& window)
+{
+  gtk_window_group_add_window(gobj(), (window).gobj());
+}
+
+void WindowGroup::remove_window(Window& window)
+{
+  gtk_window_group_remove_window(gobj(), (window).gobj());
+}
 
 
 } // namespace Gtk
diff --git a/libs/gtkmm2/gtk/gtkmm/window.h b/libs/gtkmm2/gtk/gtkmm/window.h
index f9424e2de9..442c68a011 100644
--- a/libs/gtkmm2/gtk/gtkmm/window.h
+++ b/libs/gtkmm2/gtk/gtkmm/window.h
@@ -3,7 +3,6 @@
 #ifndef _GTKMM_WINDOW_H
 #define _GTKMM_WINDOW_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -33,112 +32,27 @@
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkWindowGroup GtkWindowGroup;
-typedef struct _GtkWindowGroupClass GtkWindowGroupClass;
+typedef struct _GtkWindow GtkWindow;
+typedef struct _GtkWindowClass GtkWindowClass;
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
 namespace Gtk
-{ class WindowGroup_Class; } // namespace Gtk
+{ class Window_Class; } // namespace Gtk
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GtkWindow GtkWindow;
-typedef struct _GtkWindowClass GtkWindowClass;
+typedef struct _GtkWindowGroup GtkWindowGroup;
+typedef struct _GtkWindowGroupClass GtkWindowGroupClass;
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
 
 namespace Gtk
-{ class Window_Class; } // namespace Gtk
+{ class WindowGroup_Class; } // namespace Gtk
 namespace Gtk
 {
 
 class AccelGroup;
 class WindowGroup;
 
-/** TODO
- */
-
-class WindowGroup : public Glib::Object
-{
-  
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef WindowGroup CppObjectType;
-  typedef WindowGroup_Class CppClassType;
-  typedef GtkWindowGroup BaseObjectType;
-  typedef GtkWindowGroupClass BaseClassType;
-
-private:  friend class WindowGroup_Class;
-  static CppClassType windowgroup_class_;
-
-private:
-  // noncopyable
-  WindowGroup(const WindowGroup&);
-  WindowGroup& operator=(const WindowGroup&);
-
-protected:
-  explicit WindowGroup(const Glib::ConstructParams& construct_params);
-  explicit WindowGroup(GtkWindowGroup* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~WindowGroup();
-
-#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 GObject.
-  GtkWindowGroup*       gobj()       { return reinterpret_cast<GtkWindowGroup*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.
-  const GtkWindowGroup* gobj() const { return reinterpret_cast<GtkWindowGroup*>(gobject_); }
-
-  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
-  GtkWindowGroup* gobj_copy();
-
-private:
-
-
-protected:
-  WindowGroup();
-
-public:
-  
-  static Glib::RefPtr<WindowGroup> create();
-
-
-  /** Adds a window to a Gtk::WindowGroup.
-   * @param window The Gtk::Window to add.
-   */
-  void add_window(Window& window);
-  
-  /** Removes a window from a Gtk::WindowGroup.
-   * @param window The Gtk::Window to remove.
-   */
-  void remove_window(Window& window);
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
 
 /** Toplevel Window
  * This represents all widgets which are physical windows controlled
@@ -193,19 +107,13 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   virtual void on_set_focus(Widget* focus);
   virtual bool on_frame_event(GdkEvent* event);
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 private:
@@ -214,17 +122,14 @@ private:
 public:
    explicit Window(WindowType type = WINDOW_TOPLEVEL);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The title of the window.
+  /** The title of the window.
    *
    * 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_title() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The title of the window.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -232,19 +137,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_title() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
+  /** If TRUE
    *
    * 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_allow_shrink() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -252,19 +153,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_allow_shrink() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
+  /** If TRUE
    *
    * 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_allow_grow() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -272,19 +169,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_allow_grow() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
+  /** If TRUE
    *
    * 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_resizable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -292,19 +185,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_resizable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If TRUE
+  /** If TRUE
    *
    * 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_modal() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If TRUE
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -312,19 +201,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_modal() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The initial position of the window.
+  /** The initial position of the window.
    *
    * 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<WindowPosition> property_window_position() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The initial position of the window.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -332,19 +217,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<WindowPosition> property_window_position() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The default width of the window
+  /** The default width of the window
    *
    * 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_default_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The default width of the window
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -352,19 +233,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_default_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The default height of the window
+  /** The default height of the window
    *
    * 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_default_height() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The default height of the window
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -372,19 +249,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<int> property_default_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** If this window should be destroyed when the parent is destroyed.
+  /** If this window should be destroyed when the parent is destroyed.
    *
    * 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_destroy_with_parent() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** If this window should be destroyed when the parent is destroyed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -392,19 +265,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_destroy_with_parent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Icon for this window.
+  /** Icon for this window.
    *
    * 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_icon() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Icon for this window.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -412,20 +281,16 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_icon() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
   
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The screen where this window will be displayed.
+  /** The screen where this window will be displayed.
    *
    * 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::Screen> > property_screen() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The screen where this window will be displayed.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -433,41 +298,33 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Screen> > property_screen() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the toplevel is the current active window.
+  /** Whether the toplevel is the current active window.
    *
    * 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_is_active() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the input focus is within this GtkWindow.
+  /** Whether the input focus is within this GtkWindow.
    *
    * 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_has_toplevel_focus() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Hint to help the desktop environment understand what kind of window this is and how to treat it.
+  /** Hint to help the desktop environment understand what kind of window this is and how to treat it.
    *
    * 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<GdkWindowTypeHint> property_type_hint() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Hint to help the desktop environment understand what kind of window this is and how to treat it.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -475,19 +332,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<GdkWindowTypeHint> property_type_hint() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if the window should not be in the task bar.
+  /** TRUE if the window should not be in the task bar.
    *
    * 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_skip_taskbar_hint() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** TRUE if the window should not be in the task bar.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -495,19 +348,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_skip_taskbar_hint() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if the window should not be in the pager.
+  /** TRUE if the window should not be in the pager.
    *
    * 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_skip_pager_hint() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** TRUE if the window should not be in the pager.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -515,19 +364,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_skip_pager_hint() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
       
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Unique identifier for the window to be used when restoring a session.
+  /** Unique identifier for the window to be used when restoring a session.
    *
    * 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_role() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Unique identifier for the window to be used when restoring a session.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -535,19 +380,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_role() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the window should be decorated by the window manager.
+  /** Whether the window should be decorated by the window manager.
    *
    * 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_decorated() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** Whether the window should be decorated by the window manager.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -555,19 +396,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_decorated() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The window gravity of the window.
+  /** The window gravity of the window.
    *
    * 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::Gravity> property_gravity() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** The window gravity of the window.
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -575,73 +412,22 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Gravity> property_gravity() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if the window should be brought to the user's attention.
-   *
-   * 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_urgency_hint() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** TRUE if the window should be brought to the user's attention.
-   *
-   * 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_urgency_hint() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
- 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the window frame should have a close button.
-   *
-   * 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_deletable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether the window frame should have a close button.
-   *
-   * 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_deletable() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
- 
 
   bool is_toplevel() const;
   bool is_dialog() const;
   bool is_popup() const;
 
-   WindowType get_window_type() const;
- 
+  WindowType get_window_type() const;
+
   //: This is special to the GTK+ linux-fb port.
-   Glib::RefPtr<Gdk::Window> get_frame();
+  Glib::RefPtr<Gdk::Window> get_frame();
   Glib::RefPtr<const Gdk::Window> get_frame() const;
- 
 
-/**
-   * @par Prototype:
-   * <tt>void %set_focus(Widget* focus)</tt>
-   */
 
   Glib::SignalProxy1< void,Widget* > signal_set_focus();
 
   
-/**
-   * @par Prototype:
-   * <tt>bool %frame_event(GdkEvent* event)</tt>
-   */
-
   Glib::SignalProxy1< bool,GdkEvent* > signal_frame_event();
 
 
@@ -841,7 +627,7 @@ public:
   /** Windows may set a hint asking the desktop environment not to display
    * the window in the task bar. This function sets this hint.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param setting <tt>true</tt> to keep this window from appearing in the task bar.
    */
   void set_skip_taskbar_hint(bool setting = true);
@@ -849,7 +635,7 @@ public:
   /** Gets the value set by set_skip_taskbar_hint()
    * @return <tt>true</tt> if window shouldn't be in taskbar
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool get_skip_taskbar_hint() const;
 
@@ -860,7 +646,7 @@ public:
    * switcher that displays a thumbnail representation of the windows
    * on the screen.)
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param setting <tt>true</tt> to keep this window from appearing in the pager.
    */
   void set_skip_pager_hint(bool setting = true);
@@ -868,26 +654,10 @@ public:
   /** Gets the value set by set_skip_pager_hint().
    * @return <tt>true</tt> if window shouldn't be in pager
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   bool get_skip_pager_hint() const;
 
-  
-  /** Windows may set a hint asking the desktop environment to draw
-   * the users attention to the window. This function sets this hint.
-   * 
-   * @newin2p8
-   * @param setting <tt>true</tt> to mark this window as urgent.
-   */
-  void set_urgency_hint(bool setting = true);
-  
-  /** Gets the value set by set_urgency_hint()
-   * @return <tt>true</tt> if window is urgent
-   * 
-   * @newin2p8.
-   */
-  bool get_urgency_hint() const;
-
   //_WRAP_METHOD(void set_destroy_with_parent(bool setting = true), gtk_window_set_destroy_with_parent)
   // I don't that that this is ever a good thing for C++.murrayc.
 
@@ -947,7 +717,7 @@ public:
    * the window is already mapped, it will be unmapped, and
    * then remapped on the new screen.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param screen A Gdk::Screen.
    */
   void set_screen(const Glib::RefPtr<Gdk::Screen>& screen);
@@ -956,14 +726,14 @@ public:
   /** Returns the Gdk::Screen associated with @a window .
    * @return A Gdk::Screen.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<Gdk::Screen> get_screen();
   
   /** Returns the Gdk::Screen associated with @a window .
    * @return A Gdk::Screen.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
   Glib::RefPtr<const Gdk::Screen> get_screen() const;
 
@@ -1049,12 +819,7 @@ public:
    */
   bool get_decorated() const;
 
-  
-  void set_deletable(bool setting = true);
-  
-  bool get_deletable() const;
 
-  
   /** Retrieves the list of icons set by set_icon_list().
    * The list is copied, but the reference count on each
    * member won't be incremented.
@@ -1129,15 +894,11 @@ public:
    * @param filename Location of icon file.
    * @return <tt>true</tt> if setting the icon succeeded.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   bool set_icon_from_file(const std::string& filename);
-#else
-  bool set_icon_from_file(const std::string& filename, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
 
+  
   /** Gets the value set by set_icon() (or if you've
    * called set_icon_list(), gets the first icon in
    * the icon list).
@@ -1177,14 +938,9 @@ public:
    * @param filename Location of icon file.
    * @return <tt>true</tt> if setting the icon succeeded.
    * 
-   * @newin2p2.
+   * Since: 2.2.
    */
-#ifdef GLIBMM_EXCEPTIONS_ENABLED
   static bool set_default_icon_from_file(const std::string& filename);
-#else
-  static bool set_default_icon_from_file(const std::string& filename, std::auto_ptr<Glib::Error>& error);
-#endif //GLIBMM_EXCEPTIONS_ENABLED
-
   
   /** By default, after showing the first Gtk::Window for each Gdk::Screen,
    * GTK+ calls gdk_screen_notify_startup_complete().  Call this
@@ -1197,7 +953,7 @@ public:
    * temporarily, show your splash screen, then re-enable it so that
    * showing the main window would automatically result in notification.
    * 
-   * @newin2p2
+   * Since: 2.2
    * @param setting <tt>true</tt> to automatically do startup notification.
    */
   static void set_auto_startup_notification(bool setting = true);
@@ -1282,21 +1038,8 @@ public:
    * currently open, and the user chooses Preferences from the menu
    * a second time; use present() to move the already-open dialog
    * where the user can see it.
-   * 
-   * If you are calling this function in response to a user interaction,
-   * it is preferable to use gdk_window_present_with_time().
    */
   void present();
-  
-  /** Presents a window to the user in response to a user interaction.
-   * If you need to present a window without a timestamp, use 
-   * present(). See present() for details. 
-   * 
-   * @newin2p8
-   * @param timestamp The timestamp of the user interaction (typically a 
-   * button or key press event) which triggered this call.
-   */
-  void present(guint32 timestamp);
 
   
   /** Asks to iconify (i.e.\ minimize) the specified @a window . Note that
@@ -1392,7 +1135,7 @@ public:
    * You can track the fullscreen state via the "window_state_event" signal
    * on Gtk::Widget.
    * 
-   * @newin2p2
+   * Since: 2.2
    */
   void fullscreen();
   
@@ -1406,7 +1149,7 @@ public:
    * You can track the fullscreen state via the "window_state_event" signal
    * on Gtk::Widget.
    * 
-   * @newin2p2
+   * Since: 2.2
    */
   void unfullscreen();
         
@@ -1579,7 +1322,7 @@ public:
    * gdk_screen_height() - window_height)</tt>.
    * 
    * The Extended Window Manager Hints specification at 
-   * http://www.freedesktop.org/Standards/wm-spec has a 
+   * http://www.freedesktop.org/standards/wm-spec has a 
    * nice table of gravities in the "implementation notes" section.
    * 
    * The get_position() documentation may also be relevant.
@@ -1653,21 +1396,11 @@ public:
    * on the window.
    * 
    * @code
-   * #include &lt;gtk/gtk.h&gt;
-   * 
-   * static void
-   * fill_with_content (GtkWidget *vbox)
-   * {
-   * /&lt;!-- --&gt;* fill with content... *&lt;!-- --&gt;/
-   * }
-   * 
    * int
    * main (int argc, char *argv[])
    * {
-   * GtkWidget *window, *vbox;
-   * GdkGeometry size_hints = {
-   * 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST  
-   * };
+   * GtkWidget *window, vbox;
+   * GdkGeometry size_hints;
    * 
    * gtk_init (&amp;argc, &amp;argv);
    * 
@@ -1678,6 +1411,10 @@ public:
    * fill_with_content (vbox);
    * gtk_widget_show_all (vbox);
    * 
+   * size_hints = {
+   * 100, 50, 0, 0, 100, 50, 10, 10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST  
+   * };
+   * 
    * gtk_window_set_geometry_hints (GTK_WINDOW (window),
    * window,
    * &amp;size_hints,
@@ -1703,11 +1440,6 @@ public:
   bool parse_geometry(const Glib::ustring& geometry);
 
   
-  Glib::RefPtr<WindowGroup> get_group();
-  
-  Glib::RefPtr<const WindowGroup> get_group() const;
-
-  
   /** Hides @a window , then reshows it, resetting the
    * default size and position of the window. Used
    * by GUI builders only.
@@ -1718,7 +1450,7 @@ public:
   /** Sets an icon to be used as fallback for windows that haven't
    * had set_icon() called on them from a pixbuf.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param icon The icon.
    */
   static void set_default_icon(const Glib::RefPtr<Gdk::Pixbuf>& icon);
@@ -1737,12 +1469,11 @@ public:
    * You can track the above state via the "window_state_event" signal
    * on Gtk::Widget.
    * 
-   * Note that, according to the Extended Window 
-   * Manager Hints specification, the above state is mainly meant 
-   * for user preferences and should not be used by applications e.g. for 
-   * drawing attention to their dialogs.
+   * Note that, according to the Extended Window Manager Hints
+   * specification, the above state is mainly meant for user preferences and should not be used 
+   * by applications e.g. for drawing attention to their dialogs.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param setting Whether to keep @a window  above other windows.
    */
   void set_keep_above(bool setting = true);
@@ -1761,12 +1492,11 @@ public:
    * You can track the below state via the "window_state_event" signal
    * on Gtk::Widget.
    * 
-   * Note that, according to the Extended Window 
-   * Manager Hints specification, the above state is mainly meant 
-   * for user preferences and should not be used by applications e.g. for 
-   * drawing attention to their dialogs.
+   * Note that, according to the Extended Window Manager Hints
+   * specification, the above state is mainly meant for user preferences and should not be used 
+   * by applications e.g. for drawing attention to their dialogs.
    * 
-   * @newin2p4
+   * Since: 2.4
    * @param setting Whether to keep @a window  below other windows.
    */
   void set_keep_below(bool setting = true);
@@ -1802,29 +1532,105 @@ private:
 };
 
 
+class WindowGroup : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef WindowGroup CppObjectType;
+  typedef WindowGroup_Class CppClassType;
+  typedef GtkWindowGroup BaseObjectType;
+  typedef GtkWindowGroupClass BaseClassType;
+
+private:  friend class WindowGroup_Class;
+  static CppClassType windowgroup_class_;
+
+private:
+  // noncopyable
+  WindowGroup(const WindowGroup&);
+  WindowGroup& operator=(const WindowGroup&);
+
+protected:
+  explicit WindowGroup(const Glib::ConstructParams& construct_params);
+  explicit WindowGroup(GtkWindowGroup* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~WindowGroup();
+
+#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 GObject.
+  GtkWindowGroup*       gobj()       { return reinterpret_cast<GtkWindowGroup*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GtkWindowGroup* gobj() const { return reinterpret_cast<GtkWindowGroup*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GtkWindowGroup* gobj_copy();
+
+private:
+
+
+protected:
+  WindowGroup();
+
+public:
+  
+  static Glib::RefPtr<WindowGroup> create();
+
+
+  /** Adds a window to a Gtk::WindowGroup.
+   * @param window The Gtk::Window to add.
+   */
+  void add_window(Window& window);
+  
+  /** Removes a window from a Gtk::WindowGroup.
+   * @param window The Gtk::Window to remove.
+   */
+  void remove_window(Window& window);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
 } // namespace Gtk
 
 
 namespace Glib
 {
-  /** @relates Gtk::WindowGroup
+  /** @relates Gtk::Window
    * @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<Gtk::WindowGroup> wrap(GtkWindowGroup* object, bool take_copy = false);
+  Gtk::Window* wrap(GtkWindow* object, bool take_copy = false);
 }
 
-
 namespace Glib
 {
-  /** @relates Gtk::Window
+  /** @relates Gtk::WindowGroup
    * @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.
    */
-  Gtk::Window* wrap(GtkWindow* object, bool take_copy = false);
-} //namespace Glib
+  Glib::RefPtr<Gtk::WindowGroup> wrap(GtkWindowGroup* object, bool take_copy = false);
+}
 
 
 #endif /* _GTKMM_WINDOW_H */
diff --git a/libs/gtkmm2/gtk/gtkmm/wrap_init.cc b/libs/gtkmm2/gtk/gtkmm/wrap_init.cc
index 6bf54af509..9c1713c033 100644
--- a/libs/gtkmm2/gtk/gtkmm/wrap_init.cc
+++ b/libs/gtkmm2/gtk/gtkmm/wrap_init.cc
@@ -12,10 +12,8 @@
 
 // #include the widget headers so that we can call the get_type() static methods:
 
-#include "pagesetupunixdialog.h"
-#include "printunixdialog.h"
-#include "printer.h"
-#include "printjob.h"
+#include "plug.h"
+#include "socket.h"
 #include "aboutdialog.h"
 #include "accelgroup.h"
 #include "accellabel.h"
@@ -25,7 +23,6 @@
 #include "alignment.h"
 #include "arrow.h"
 #include "aspectframe.h"
-#include "assistant.h"
 #include "bin.h"
 #include "box.h"
 #include "button.h"
@@ -35,11 +32,9 @@
 #include "celllayout.h"
 #include "cellview.h"
 #include "cellrenderer.h"
-#include "cellrendereraccel.h"
 #include "cellrenderercombo.h"
 #include "cellrendererpixbuf.h"
 #include "cellrendererprogress.h"
-#include "cellrendererspin.h"
 #include "cellrenderertext.h"
 #include "cellrenderertoggle.h"
 #include "checkbutton.h"
@@ -83,7 +78,6 @@
 #include "item.h"
 #include "label.h"
 #include "layout.h"
-#include "linkbutton.h"
 #include "liststore.h"
 #include "main.h"
 #include "menu.h"
@@ -97,27 +91,13 @@
 #include "object.h"
 #include "optionmenu.h"
 #include "paned.h"
-#include "plug.h"
 #include "progressbar.h"
-#include "papersize.h"
-#include "pagesetup.h"
-#include "printsettings.h"
-#include "printcontext.h"
-#include "printoperation.h"
-#include "printoperationpreview.h"
 #include "radioaction.h"
 #include "radiobutton.h"
 #include "radiomenuitem.h"
 #include "radiotoolbutton.h"
 #include "range.h"
 #include "rc.h"
-#include "recentchooser.h"
-#include "recentchooserdialog.h"
-#include "recentchoosermenu.h"
-#include "recentchooserwidget.h"
-#include "recentfilter.h"
-#include "recentinfo.h"
-#include "recentmanager.h"
 #include "ruler.h"
 #include "scale.h"
 #include "scrollbar.h"
@@ -128,10 +108,8 @@
 #include "separatortoolitem.h"
 #include "settings.h"
 #include "sizegroup.h"
-#include "socket.h"
 #include "spinbutton.h"
 #include "statusbar.h"
-#include "statusicon.h"
 #include "stockitem.h"
 #include "style.h"
 #include "table.h"
@@ -185,18 +163,15 @@ GType gtk_adjustment_get_type(void);
 GType gtk_alignment_get_type(void);
 GType gtk_arrow_get_type(void);
 GType gtk_aspect_frame_get_type(void);
-GType gtk_assistant_get_type(void);
 GType gtk_bin_get_type(void);
 GType gtk_box_get_type(void);
 GType gtk_button_get_type(void);
 GType gtk_button_box_get_type(void);
 GType gtk_calendar_get_type(void);
 GType gtk_cell_renderer_get_type(void);
-GType gtk_cell_renderer_accel_get_type(void);
 GType gtk_cell_renderer_combo_get_type(void);
 GType gtk_cell_renderer_pixbuf_get_type(void);
 GType gtk_cell_renderer_progress_get_type(void);
-GType gtk_cell_renderer_spin_get_type(void);
 GType gtk_cell_renderer_text_get_type(void);
 GType gtk_cell_renderer_toggle_get_type(void);
 GType gtk_cell_view_get_type(void);
@@ -206,17 +181,11 @@ GType gtk_clipboard_get_type(void);
 GType gtk_color_button_get_type(void);
 GType gtk_color_selection_get_type(void);
 GType gtk_color_selection_dialog_get_type(void);
-#ifndef GTKMM_DISABLE_DEPRECATED
 GType gtk_combo_get_type(void);
-#endif // *_DISABLE_DEPRECATED
 GType gtk_combo_box_get_type(void);
 GType gtk_combo_box_entry_get_type(void);
-#ifndef GTKMM_DISABLE_DEPRECATED
 GType gtk_list_get_type(void);
-#endif // *_DISABLE_DEPRECATED
-#ifndef GTKMM_DISABLE_DEPRECATED
 GType gtk_list_item_get_type(void);
-#endif // *_DISABLE_DEPRECATED
 GType gtk_container_get_type(void);
 GType gtk_curve_get_type(void);
 GType gtk_dialog_get_type(void);
@@ -229,9 +198,7 @@ GType gtk_file_chooser_button_get_type(void);
 GType gtk_file_chooser_dialog_get_type(void);
 GType gtk_file_chooser_widget_get_type(void);
 GType gtk_file_filter_get_type(void);
-#ifndef GTKMM_DISABLE_DEPRECATED
 GType gtk_file_selection_get_type(void);
-#endif // *_DISABLE_DEPRECATED
 GType gtk_fixed_get_type(void);
 GType gtk_font_button_get_type(void);
 GType gtk_font_selection_get_type(void);
@@ -256,7 +223,6 @@ GType gtk_invisible_get_type(void);
 GType gtk_item_get_type(void);
 GType gtk_label_get_type(void);
 GType gtk_layout_get_type(void);
-GType gtk_link_button_get_type(void);
 GType gtk_list_store_get_type(void);
 GType gtk_menu_get_type(void);
 GType gtk_menu_bar_get_type(void);
@@ -267,29 +233,11 @@ GType gtk_message_dialog_get_type(void);
 GType gtk_misc_get_type(void);
 GType gtk_notebook_get_type(void);
 GType gtk_object_get_type(void);
-#ifndef GTKMM_DISABLE_DEPRECATED
 GType gtk_option_menu_get_type(void);
-#endif // *_DISABLE_DEPRECATED
-GType gtk_page_setup_get_type(void);
-#ifndef G_OS_WIN32
-GType gtk_page_setup_unix_dialog_get_type(void);
-#endif //G_OS_WIN32
 GType gtk_paned_get_type(void);
 #ifndef G_OS_WIN32
 GType gtk_plug_get_type(void);
 #endif //G_OS_WIN32
-GType gtk_print_context_get_type(void);
-#ifndef G_OS_WIN32
-GType gtk_print_job_get_type(void);
-#endif //G_OS_WIN32
-GType gtk_print_operation_get_type(void);
-GType gtk_print_settings_get_type(void);
-#ifndef G_OS_WIN32
-GType gtk_print_unix_dialog_get_type(void);
-#endif //G_OS_WIN32
-#ifndef G_OS_WIN32
-GType gtk_printer_get_type(void);
-#endif //G_OS_WIN32
 GType gtk_progress_bar_get_type(void);
 GType gtk_radio_action_get_type(void);
 GType gtk_radio_button_get_type(void);
@@ -297,11 +245,6 @@ GType gtk_radio_menu_item_get_type(void);
 GType gtk_radio_tool_button_get_type(void);
 GType gtk_range_get_type(void);
 GType gtk_rc_style_get_type(void);
-GType gtk_recent_chooser_dialog_get_type(void);
-GType gtk_recent_chooser_menu_get_type(void);
-GType gtk_recent_chooser_widget_get_type(void);
-GType gtk_recent_filter_get_type(void);
-GType gtk_recent_manager_get_type(void);
 GType gtk_ruler_get_type(void);
 GType gtk_scale_get_type(void);
 GType gtk_scrollbar_get_type(void);
@@ -315,7 +258,6 @@ GType gtk_size_group_get_type(void);
 GType gtk_socket_get_type(void);
 #endif //G_OS_WIN32
 GType gtk_spin_button_get_type(void);
-GType gtk_status_icon_get_type(void);
 GType gtk_statusbar_get_type(void);
 GType gtk_style_get_type(void);
 GType gtk_table_get_type(void);
@@ -356,9 +298,6 @@ GType gtk_window_group_get_type(void);
 
 GQuark gtk_file_chooser_error_quark(void);
 GQuark gtk_icon_theme_error_quark(void);
-GQuark gtk_print_error_quark(void);
-GQuark gtk_recent_chooser_error_quark(void);
-GQuark gtk_recent_manager_error_quark(void);
 } // extern "C"
 
 
@@ -373,18 +312,15 @@ namespace Gtk {  class Adjustment_Class { public: static Glib::ObjectBase* wrap_
 namespace Gtk {  class Alignment_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Arrow_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class AspectFrame_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class Assistant_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Bin_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Box_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Button_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class ButtonBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Calendar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class CellRenderer_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class CellRendererAccel_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class CellRendererCombo_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class CellRendererPixbuf_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class CellRendererProgress_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class CellRendererSpin_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class CellRendererText_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class CellRendererToggle_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class CellView_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
@@ -394,17 +330,11 @@ namespace Gtk {  class Clipboard_Class { public: static Glib::ObjectBase* wrap_n
 namespace Gtk {  class ColorButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class ColorSelection_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class ColorSelectionDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#ifndef GTKMM_DISABLE_DEPRECATED
 namespace Gtk {  class Combo_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif // *_DISABLE_DEPRECATED
 namespace Gtk {  class ComboBox_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class ComboBoxEntry_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#ifndef GTKMM_DISABLE_DEPRECATED
 namespace Gtk {  class ComboDropDown_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif // *_DISABLE_DEPRECATED
-#ifndef GTKMM_DISABLE_DEPRECATED
 namespace Gtk {  class ComboDropDownItem_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif // *_DISABLE_DEPRECATED
 namespace Gtk {  class Container_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Curve_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Dialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
@@ -417,9 +347,7 @@ namespace Gtk {  class FileChooserButton_Class { public: static Glib::ObjectBase
 namespace Gtk {  class FileChooserDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class FileChooserWidget_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class FileFilter_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#ifndef GTKMM_DISABLE_DEPRECATED
 namespace Gtk {  class FileSelection_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif // *_DISABLE_DEPRECATED
 namespace Gtk {  class Fixed_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class FontButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class FontSelection_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
@@ -444,7 +372,6 @@ namespace Gtk {  class Invisible_Class { public: static Glib::ObjectBase* wrap_n
 namespace Gtk {  class Item_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Label_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Layout_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class LinkButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class ListStore_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Menu_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class MenuBar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
@@ -455,29 +382,11 @@ namespace Gtk {  class MessageDialog_Class { public: static Glib::ObjectBase* wr
 namespace Gtk {  class Misc_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Notebook_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Object_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#ifndef GTKMM_DISABLE_DEPRECATED
 namespace Gtk {  class OptionMenu_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif // *_DISABLE_DEPRECATED
-namespace Gtk {  class PageSetup_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#ifndef G_OS_WIN32
-namespace Gtk {  class PageSetupUnixDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif //G_OS_WIN32
 namespace Gtk {  class Paned_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 #ifndef G_OS_WIN32
 namespace Gtk {  class Plug_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 #endif //G_OS_WIN32
-namespace Gtk {  class PrintContext_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#ifndef G_OS_WIN32
-namespace Gtk {  class PrintJob_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif //G_OS_WIN32
-namespace Gtk {  class PrintOperation_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class PrintSettings_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#ifndef G_OS_WIN32
-namespace Gtk {  class PrintUnixDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif //G_OS_WIN32
-#ifndef G_OS_WIN32
-namespace Gtk {  class Printer_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-#endif //G_OS_WIN32
 namespace Gtk {  class ProgressBar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class RadioAction_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class RadioButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
@@ -485,11 +394,6 @@ namespace Gtk {  class RadioMenuItem_Class { public: static Glib::ObjectBase* wr
 namespace Gtk {  class RadioToolButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Range_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class RcStyle_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class RecentChooserDialog_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class RecentChooserMenu_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class RecentChooserWidget_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class RecentFilter_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class RecentManager_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Ruler_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Scale_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Scrollbar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
@@ -503,7 +407,6 @@ namespace Gtk {  class SizeGroup_Class { public: static Glib::ObjectBase* wrap_n
 namespace Gtk {  class Socket_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 #endif //G_OS_WIN32
 namespace Gtk {  class SpinButton_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
-namespace Gtk {  class StatusIcon_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Statusbar_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Style_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
 namespace Gtk {  class Table_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  }
@@ -547,9 +450,6 @@ void wrap_init()
   // Register Error domains:
   Glib::Error::register_domain(gtk_file_chooser_error_quark(), &Gtk::FileChooserError::throw_func);
   Glib::Error::register_domain(gtk_icon_theme_error_quark(), &Gtk::IconThemeError::throw_func);
-  Glib::Error::register_domain(gtk_print_error_quark(), &Gtk::PrintError::throw_func);
-  Glib::Error::register_domain(gtk_recent_chooser_error_quark(), &Gtk::RecentChooserError::throw_func);
-  Glib::Error::register_domain(gtk_recent_manager_error_quark(), &Gtk::RecentManagerError::throw_func);
 
 // Map gtypes to gtkmm wrapper-creation functions:
   Glib::wrap_register(gtk_about_dialog_get_type(), &Gtk::AboutDialog_Class::wrap_new);
@@ -561,18 +461,15 @@ void wrap_init()
   Glib::wrap_register(gtk_alignment_get_type(), &Gtk::Alignment_Class::wrap_new);
   Glib::wrap_register(gtk_arrow_get_type(), &Gtk::Arrow_Class::wrap_new);
   Glib::wrap_register(gtk_aspect_frame_get_type(), &Gtk::AspectFrame_Class::wrap_new);
-  Glib::wrap_register(gtk_assistant_get_type(), &Gtk::Assistant_Class::wrap_new);
   Glib::wrap_register(gtk_bin_get_type(), &Gtk::Bin_Class::wrap_new);
   Glib::wrap_register(gtk_box_get_type(), &Gtk::Box_Class::wrap_new);
   Glib::wrap_register(gtk_button_get_type(), &Gtk::Button_Class::wrap_new);
   Glib::wrap_register(gtk_button_box_get_type(), &Gtk::ButtonBox_Class::wrap_new);
   Glib::wrap_register(gtk_calendar_get_type(), &Gtk::Calendar_Class::wrap_new);
   Glib::wrap_register(gtk_cell_renderer_get_type(), &Gtk::CellRenderer_Class::wrap_new);
-  Glib::wrap_register(gtk_cell_renderer_accel_get_type(), &Gtk::CellRendererAccel_Class::wrap_new);
   Glib::wrap_register(gtk_cell_renderer_combo_get_type(), &Gtk::CellRendererCombo_Class::wrap_new);
   Glib::wrap_register(gtk_cell_renderer_pixbuf_get_type(), &Gtk::CellRendererPixbuf_Class::wrap_new);
   Glib::wrap_register(gtk_cell_renderer_progress_get_type(), &Gtk::CellRendererProgress_Class::wrap_new);
-  Glib::wrap_register(gtk_cell_renderer_spin_get_type(), &Gtk::CellRendererSpin_Class::wrap_new);
   Glib::wrap_register(gtk_cell_renderer_text_get_type(), &Gtk::CellRendererText_Class::wrap_new);
   Glib::wrap_register(gtk_cell_renderer_toggle_get_type(), &Gtk::CellRendererToggle_Class::wrap_new);
   Glib::wrap_register(gtk_cell_view_get_type(), &Gtk::CellView_Class::wrap_new);
@@ -582,17 +479,11 @@ void wrap_init()
   Glib::wrap_register(gtk_color_button_get_type(), &Gtk::ColorButton_Class::wrap_new);
   Glib::wrap_register(gtk_color_selection_get_type(), &Gtk::ColorSelection_Class::wrap_new);
   Glib::wrap_register(gtk_color_selection_dialog_get_type(), &Gtk::ColorSelectionDialog_Class::wrap_new);
-#ifndef GTKMM_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_combo_get_type(), &Gtk::Combo_Class::wrap_new);
-#endif // *_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_combo_box_get_type(), &Gtk::ComboBox_Class::wrap_new);
   Glib::wrap_register(gtk_combo_box_entry_get_type(), &Gtk::ComboBoxEntry_Class::wrap_new);
-#ifndef GTKMM_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_list_get_type(), &Gtk::ComboDropDown_Class::wrap_new);
-#endif // *_DISABLE_DEPRECATED
-#ifndef GTKMM_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_list_item_get_type(), &Gtk::ComboDropDownItem_Class::wrap_new);
-#endif // *_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_container_get_type(), &Gtk::Container_Class::wrap_new);
   Glib::wrap_register(gtk_curve_get_type(), &Gtk::Curve_Class::wrap_new);
   Glib::wrap_register(gtk_dialog_get_type(), &Gtk::Dialog_Class::wrap_new);
@@ -605,9 +496,7 @@ void wrap_init()
   Glib::wrap_register(gtk_file_chooser_dialog_get_type(), &Gtk::FileChooserDialog_Class::wrap_new);
   Glib::wrap_register(gtk_file_chooser_widget_get_type(), &Gtk::FileChooserWidget_Class::wrap_new);
   Glib::wrap_register(gtk_file_filter_get_type(), &Gtk::FileFilter_Class::wrap_new);
-#ifndef GTKMM_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_file_selection_get_type(), &Gtk::FileSelection_Class::wrap_new);
-#endif // *_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_fixed_get_type(), &Gtk::Fixed_Class::wrap_new);
   Glib::wrap_register(gtk_font_button_get_type(), &Gtk::FontButton_Class::wrap_new);
   Glib::wrap_register(gtk_font_selection_get_type(), &Gtk::FontSelection_Class::wrap_new);
@@ -632,7 +521,6 @@ void wrap_init()
   Glib::wrap_register(gtk_item_get_type(), &Gtk::Item_Class::wrap_new);
   Glib::wrap_register(gtk_label_get_type(), &Gtk::Label_Class::wrap_new);
   Glib::wrap_register(gtk_layout_get_type(), &Gtk::Layout_Class::wrap_new);
-  Glib::wrap_register(gtk_link_button_get_type(), &Gtk::LinkButton_Class::wrap_new);
   Glib::wrap_register(gtk_list_store_get_type(), &Gtk::ListStore_Class::wrap_new);
   Glib::wrap_register(gtk_menu_get_type(), &Gtk::Menu_Class::wrap_new);
   Glib::wrap_register(gtk_menu_bar_get_type(), &Gtk::MenuBar_Class::wrap_new);
@@ -643,29 +531,11 @@ void wrap_init()
   Glib::wrap_register(gtk_misc_get_type(), &Gtk::Misc_Class::wrap_new);
   Glib::wrap_register(gtk_notebook_get_type(), &Gtk::Notebook_Class::wrap_new);
   Glib::wrap_register(gtk_object_get_type(), &Gtk::Object_Class::wrap_new);
-#ifndef GTKMM_DISABLE_DEPRECATED
   Glib::wrap_register(gtk_option_menu_get_type(), &Gtk::OptionMenu_Class::wrap_new);
-#endif // *_DISABLE_DEPRECATED
-  Glib::wrap_register(gtk_page_setup_get_type(), &Gtk::PageSetup_Class::wrap_new);
-#ifndef G_OS_WIN32
-  Glib::wrap_register(gtk_page_setup_unix_dialog_get_type(), &Gtk::PageSetupUnixDialog_Class::wrap_new);
-#endif //G_OS_WIN32
   Glib::wrap_register(gtk_paned_get_type(), &Gtk::Paned_Class::wrap_new);
 #ifndef G_OS_WIN32
   Glib::wrap_register(gtk_plug_get_type(), &Gtk::Plug_Class::wrap_new);
 #endif //G_OS_WIN32
-  Glib::wrap_register(gtk_print_context_get_type(), &Gtk::PrintContext_Class::wrap_new);
-#ifndef G_OS_WIN32
-  Glib::wrap_register(gtk_print_job_get_type(), &Gtk::PrintJob_Class::wrap_new);
-#endif //G_OS_WIN32
-  Glib::wrap_register(gtk_print_operation_get_type(), &Gtk::PrintOperation_Class::wrap_new);
-  Glib::wrap_register(gtk_print_settings_get_type(), &Gtk::PrintSettings_Class::wrap_new);
-#ifndef G_OS_WIN32
-  Glib::wrap_register(gtk_print_unix_dialog_get_type(), &Gtk::PrintUnixDialog_Class::wrap_new);
-#endif //G_OS_WIN32
-#ifndef G_OS_WIN32
-  Glib::wrap_register(gtk_printer_get_type(), &Gtk::Printer_Class::wrap_new);
-#endif //G_OS_WIN32
   Glib::wrap_register(gtk_progress_bar_get_type(), &Gtk::ProgressBar_Class::wrap_new);
   Glib::wrap_register(gtk_radio_action_get_type(), &Gtk::RadioAction_Class::wrap_new);
   Glib::wrap_register(gtk_radio_button_get_type(), &Gtk::RadioButton_Class::wrap_new);
@@ -673,11 +543,6 @@ void wrap_init()
   Glib::wrap_register(gtk_radio_tool_button_get_type(), &Gtk::RadioToolButton_Class::wrap_new);
   Glib::wrap_register(gtk_range_get_type(), &Gtk::Range_Class::wrap_new);
   Glib::wrap_register(gtk_rc_style_get_type(), &Gtk::RcStyle_Class::wrap_new);
-  Glib::wrap_register(gtk_recent_chooser_dialog_get_type(), &Gtk::RecentChooserDialog_Class::wrap_new);
-  Glib::wrap_register(gtk_recent_chooser_menu_get_type(), &Gtk::RecentChooserMenu_Class::wrap_new);
-  Glib::wrap_register(gtk_recent_chooser_widget_get_type(), &Gtk::RecentChooserWidget_Class::wrap_new);
-  Glib::wrap_register(gtk_recent_filter_get_type(), &Gtk::RecentFilter_Class::wrap_new);
-  Glib::wrap_register(gtk_recent_manager_get_type(), &Gtk::RecentManager_Class::wrap_new);
   Glib::wrap_register(gtk_ruler_get_type(), &Gtk::Ruler_Class::wrap_new);
   Glib::wrap_register(gtk_scale_get_type(), &Gtk::Scale_Class::wrap_new);
   Glib::wrap_register(gtk_scrollbar_get_type(), &Gtk::Scrollbar_Class::wrap_new);
@@ -691,7 +556,6 @@ void wrap_init()
   Glib::wrap_register(gtk_socket_get_type(), &Gtk::Socket_Class::wrap_new);
 #endif //G_OS_WIN32
   Glib::wrap_register(gtk_spin_button_get_type(), &Gtk::SpinButton_Class::wrap_new);
-  Glib::wrap_register(gtk_status_icon_get_type(), &Gtk::StatusIcon_Class::wrap_new);
   Glib::wrap_register(gtk_statusbar_get_type(), &Gtk::Statusbar_Class::wrap_new);
   Glib::wrap_register(gtk_style_get_type(), &Gtk::Style_Class::wrap_new);
   Glib::wrap_register(gtk_table_get_type(), &Gtk::Table_Class::wrap_new);
@@ -738,18 +602,15 @@ void wrap_init()
   Gtk::Alignment::get_type();
   Gtk::Arrow::get_type();
   Gtk::AspectFrame::get_type();
-  Gtk::Assistant::get_type();
   Gtk::Bin::get_type();
   Gtk::Box::get_type();
   Gtk::Button::get_type();
   Gtk::ButtonBox::get_type();
   Gtk::Calendar::get_type();
   Gtk::CellRenderer::get_type();
-  Gtk::CellRendererAccel::get_type();
   Gtk::CellRendererCombo::get_type();
   Gtk::CellRendererPixbuf::get_type();
   Gtk::CellRendererProgress::get_type();
-  Gtk::CellRendererSpin::get_type();
   Gtk::CellRendererText::get_type();
   Gtk::CellRendererToggle::get_type();
   Gtk::CellView::get_type();
@@ -759,17 +620,11 @@ void wrap_init()
   Gtk::ColorButton::get_type();
   Gtk::ColorSelection::get_type();
   Gtk::ColorSelectionDialog::get_type();
-#ifndef GTKMM_DISABLE_DEPRECATED
   Gtk::Combo::get_type();
-#endif // *_DISABLE_DEPRECATED
   Gtk::ComboBox::get_type();
   Gtk::ComboBoxEntry::get_type();
-#ifndef GTKMM_DISABLE_DEPRECATED
   Gtk::ComboDropDown::get_type();
-#endif // *_DISABLE_DEPRECATED
-#ifndef GTKMM_DISABLE_DEPRECATED
   Gtk::ComboDropDownItem::get_type();
-#endif // *_DISABLE_DEPRECATED
   Gtk::Container::get_type();
   Gtk::Curve::get_type();
   Gtk::Dialog::get_type();
@@ -782,9 +637,7 @@ void wrap_init()
   Gtk::FileChooserDialog::get_type();
   Gtk::FileChooserWidget::get_type();
   Gtk::FileFilter::get_type();
-#ifndef GTKMM_DISABLE_DEPRECATED
   Gtk::FileSelection::get_type();
-#endif // *_DISABLE_DEPRECATED
   Gtk::Fixed::get_type();
   Gtk::FontButton::get_type();
   Gtk::FontSelection::get_type();
@@ -809,7 +662,6 @@ void wrap_init()
   Gtk::Item::get_type();
   Gtk::Label::get_type();
   Gtk::Layout::get_type();
-  Gtk::LinkButton::get_type();
   Gtk::ListStore::get_type();
   Gtk::Menu::get_type();
   Gtk::MenuBar::get_type();
@@ -820,29 +672,11 @@ void wrap_init()
   Gtk::Misc::get_type();
   Gtk::Notebook::get_type();
   Gtk::Object::get_type();
-#ifndef GTKMM_DISABLE_DEPRECATED
   Gtk::OptionMenu::get_type();
-#endif // *_DISABLE_DEPRECATED
-  Gtk::PageSetup::get_type();
-#ifndef G_OS_WIN32
-  Gtk::PageSetupUnixDialog::get_type();
-#endif //G_OS_WIN32
   Gtk::Paned::get_type();
 #ifndef G_OS_WIN32
   Gtk::Plug::get_type();
 #endif //G_OS_WIN32
-  Gtk::PrintContext::get_type();
-#ifndef G_OS_WIN32
-  Gtk::PrintJob::get_type();
-#endif //G_OS_WIN32
-  Gtk::PrintOperation::get_type();
-  Gtk::PrintSettings::get_type();
-#ifndef G_OS_WIN32
-  Gtk::PrintUnixDialog::get_type();
-#endif //G_OS_WIN32
-#ifndef G_OS_WIN32
-  Gtk::Printer::get_type();
-#endif //G_OS_WIN32
   Gtk::ProgressBar::get_type();
   Gtk::RadioAction::get_type();
   Gtk::RadioButton::get_type();
@@ -850,11 +684,6 @@ void wrap_init()
   Gtk::RadioToolButton::get_type();
   Gtk::Range::get_type();
   Gtk::RcStyle::get_type();
-  Gtk::RecentChooserDialog::get_type();
-  Gtk::RecentChooserMenu::get_type();
-  Gtk::RecentChooserWidget::get_type();
-  Gtk::RecentFilter::get_type();
-  Gtk::RecentManager::get_type();
   Gtk::Ruler::get_type();
   Gtk::Scale::get_type();
   Gtk::Scrollbar::get_type();
@@ -868,7 +697,6 @@ void wrap_init()
   Gtk::Socket::get_type();
 #endif //G_OS_WIN32
   Gtk::SpinButton::get_type();
-  Gtk::StatusIcon::get_type();
   Gtk::Statusbar::get_type();
   Gtk::Style::get_type();
   Gtk::Table::get_type();
diff --git a/libs/gtkmm2/gtk/gtkmmconfig.h b/libs/gtkmm2/gtk/gtkmmconfig.h
index 8dc94ae3f3..b28315ec71 100644
--- a/libs/gtkmm2/gtk/gtkmmconfig.h
+++ b/libs/gtkmm2/gtk/gtkmmconfig.h
@@ -6,8 +6,8 @@
 
 /* version numbers */
 #define GTKMM_MAJOR_VERSION 2
-#define GTKMM_MINOR_VERSION 10
-#define GTKMM_MICRO_VERSION 7
+#define GTKMM_MINOR_VERSION 6
+#define GTKMM_MICRO_VERSION 1
 
 #ifdef GLIBMM_CONFIGURE
 /* compiler feature tests that are used during compile time and run-time
@@ -20,7 +20,6 @@
 
 /* #undef HAVE_FLOCKFILE */
 /* #undef HAVE_FUNLOCKFILE */
-/* #undef HAVE_MKFIFO */
 /* #undef GETC_UNLOCKED */
 
 #endif /* GLIBMM_CONFIGURE */
diff --git a/libs/gtkmm2/pango/SConscript b/libs/gtkmm2/pango/SConscript
index cc0b3016a4..d045cf2043 100644
--- a/libs/gtkmm2/pango/SConscript
+++ b/libs/gtkmm2/pango/SConscript
@@ -8,7 +8,7 @@ pangomm_files = glob.glob('pangomm/*.cc')
 
 Import('env libraries install_prefix')
 pangomm = env.Copy()
-pangomm.Merge([libraries['glibmm2'], libraries['cairo'], libraries['cairomm'], libraries['pango'], libraries['pangocairo'], libraries['sigc2']])
+pangomm.Merge([libraries['glibmm2'], libraries['pango'], libraries['sigc2']])
 
 libpangomm = pangomm.SharedLibrary('pangomm', pangomm_files)
 Default(libpangomm)
diff --git a/libs/gtkmm2/pango/pangomm/attributes.cc b/libs/gtkmm2/pango/pangomm/attributes.cc
index abb9428989..2d23e5d77b 100644
--- a/libs/gtkmm2/pango/pangomm/attributes.cc
+++ b/libs/gtkmm2/pango/pangomm/attributes.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/attributes.h>
 #include <pangomm/private/attributes_p.h>
 
@@ -378,26 +377,26 @@ namespace Pango
 {
 
 
- unsigned int Attribute::get_start_index() const
+unsigned int Attribute::get_start_index() const
 {
   return gobj()->start_index;
 }
- 
- unsigned int Attribute::get_end_index() const
+
+unsigned int Attribute::get_end_index() const
 {
   return gobj()->end_index;
 }
- 
- void Attribute::set_start_index(const unsigned int& value)
+
+void Attribute::set_start_index(const unsigned int& value)
 {
   gobj()->start_index = value;
 }
- 
- void Attribute::set_end_index(const unsigned int& value)
+
+void Attribute::set_end_index(const unsigned int& value)
 {
   gobj()->end_index = value;
 }
- 
+
 bool Attribute::equal(const Attribute& attr2) const
 {
   return pango_attribute_equal(const_cast<PangoAttribute*>(gobj()), (attr2).gobj());
@@ -411,11 +410,11 @@ namespace Pango
 {
 
 
- Glib::ustring AttrString::get_string() const
+Glib::ustring AttrString::get_string() const
 {
   return Glib::convert_const_gchar_ptr_to_ustring(gobj()->value);
 }
- 
+
 
 } // namespace Pango
 
@@ -424,16 +423,16 @@ namespace Pango
 {
 
 
- Language AttrLanguage::get_language() const
+Language AttrLanguage::get_language() const
 {
   return Language(gobj()->value);
 }
- 
- void AttrLanguage::set_language(const Language& value)
+
+void AttrLanguage::set_language(const Language& value)
 {
   gobj()->value = const_cast<PangoLanguage*>((value).gobj());
 }
- 
+
 
 } // namespace Pango
 
@@ -442,16 +441,16 @@ namespace Pango
 {
 
 
- Color AttrColor::get_color() const
+Color AttrColor::get_color() const
 {
   return Color(&(gobj()->color));
 }
- 
- void AttrColor::set_color(const Color& value)
+
+void AttrColor::set_color(const Color& value)
 {
   gobj()->color = *(value).gobj();
 }
- 
+
 
 } // namespace Pango
 
@@ -460,16 +459,16 @@ namespace Pango
 {
 
 
- int AttrInt::get_value() const
+int AttrInt::get_value() const
 {
   return gobj()->value;
 }
- 
- void AttrInt::set_value(const int& value)
+
+void AttrInt::set_value(const int& value)
 {
   gobj()->value = value;
 }
- 
+
 
 } // namespace Pango
 
@@ -478,16 +477,16 @@ namespace Pango
 {
 
 
- double AttrFloat::get_value() const
+double AttrFloat::get_value() const
 {
   return gobj()->value;
 }
- 
- void AttrFloat::set_value(const double& value)
+
+void AttrFloat::set_value(const double& value)
 {
   gobj()->value = value;
 }
- 
+
 
 } // namespace Pango
 
@@ -496,11 +495,11 @@ namespace Pango
 {
 
 
- FontDescription AttrFontDesc::get_desc() const
+FontDescription AttrFontDesc::get_desc() const
 {
   return FontDescription((gobj()->desc));
 }
- 
+
 
 } // namespace Pango
 
@@ -509,26 +508,26 @@ namespace Pango
 {
 
 
- Rectangle AttrShape::get_ink_rect() const
+Rectangle AttrShape::get_ink_rect() const
 {
   return Rectangle(&(gobj()->ink_rect));
 }
- 
- Rectangle AttrShape::get_logical_rect() const
+
+Rectangle AttrShape::get_logical_rect() const
 {
   return Rectangle(&(gobj()->logical_rect));
 }
- 
- void AttrShape::set_ink_rect(const Rectangle& value)
+
+void AttrShape::set_ink_rect(const Rectangle& value)
 {
   gobj()->ink_rect = *(value).gobj();
 }
- 
- void AttrShape::set_logical_rect(const Rectangle& value)
+
+void AttrShape::set_logical_rect(const Rectangle& value)
 {
   gobj()->logical_rect = *(value).gobj();
 }
- 
+
 
 } // namespace Pango
 
diff --git a/libs/gtkmm2/pango/pangomm/attributes.h b/libs/gtkmm2/pango/pangomm/attributes.h
index 4d25d39087..25baa96475 100644
--- a/libs/gtkmm2/pango/pangomm/attributes.h
+++ b/libs/gtkmm2/pango/pangomm/attributes.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_ATTRIBUTES_H
 #define _PANGOMM_ATTRIBUTES_H
 
-
 #include <glibmm.h>
 
 /* attributes.h
@@ -65,8 +64,7 @@ enum AttrType
   ATTR_FALLBACK,
   ATTR_LETTER_SPACING,
   ATTR_UNDERLINE_COLOR,
-  ATTR_STRIKETHROUGH_COLOR,
-  ATTR_ABSOLUTE_SIZE
+  ATTR_STRIKETHROUGH_COLOR
 };
 
 } // namespace Pango
@@ -181,23 +179,23 @@ public:
   /** Gets the start index of the range.
    * @return The start index of the range.
    */
-   unsigned int get_start_index() const;
- 
+  unsigned int get_start_index() const;
+
   /** Gets the end index of the range. The character at this index is not included in the range.
    * @return The end index of the range.
    */
-   unsigned int get_end_index() const;
- 
+  unsigned int get_end_index() const;
+
   /** Sets the start index of the range.
    * @param value The new start index.
    */
-   void set_start_index(const unsigned int& value);
- 
+  void set_start_index(const unsigned int& value);
+
   /** Sets the end index of the range. The character at this index is not included in the range.
    * @param value The new end index.
    */
-   void set_end_index(const unsigned int& value);
- 
+  void set_end_index(const unsigned int& value);
+
   
   /** Compare two attributes for equality. This compares only the
    * actual value of the two attributes and not the ranges that the
@@ -354,8 +352,8 @@ public:
   /** Gets the string which is the value of the attribute.
    * @return The string value of the attribute.
    */
-   Glib::ustring get_string() const;
- 
+  Glib::ustring get_string() const;
+
   /** Sets the string which is the value of the attribute.
    * @param string The new string value for the attribute.
    */
@@ -394,13 +392,13 @@ public:
   /** Gets the language which is the value of the attribute.
    * @return The language tag of the attribute.
    */
-   Language get_language() const;
- 
+  Language get_language() const;
+
   /** Sets the language which is the value of the attribute.
    * @param value The new language tag for the attribute.
    */
-   void set_language(const Language& value);
- 
+  void set_language(const Language& value);
+
   /// Provides access to the underlying C GObject.  
   PangoAttrLanguage*       gobj()       { return reinterpret_cast<PangoAttrLanguage*>(gobject_); }
   /// Provides access to the underlying C GObject.
@@ -434,13 +432,13 @@ public:
   /** Gets the color which is the value of the attribute.
    * @return The color value of the attribute.
    */
-   Color get_color() const;
- 
+  Color get_color() const;
+
   /** Sets the color which is the value of the attribute.
    * @param value The new color value for the attribute.
    */
-   void set_color(const Color& value);
- 
+  void set_color(const Color& value);
+
   /// Provides access to the underlying C GObject.  
   PangoAttrColor*       gobj()       { return reinterpret_cast<PangoAttrColor*>(gobject_); }
   /// Provides access to the underlying C GObject.
@@ -474,13 +472,13 @@ public:
   /** Gets the integer value of the attribute.
    * @return The integer value of the attribute.
    */
-   int get_value() const;
- 
+  int get_value() const;
+
   /** Sets the integer value of the attribute.
    * @param value The new integer value for the attribute.
    */
-   void set_value(const int& value);
- 
+  void set_value(const int& value);
+
   /// Provides access to the underlying C GObject.  
   PangoAttrInt*       gobj()       { return reinterpret_cast<PangoAttrInt*>(gobject_); }
   /// Provides access to the underlying C GObject.
@@ -514,13 +512,13 @@ public:
   /** Gets the floating point value of the attribute.
    * @return The floating point value of the attribute.
    */
-   double get_value() const;
- 
+  double get_value() const;
+
   /** Sets the floating point value of the attribute.
    * @param value The new floating point value for the attribute.
    */
-   void set_value(const double& value);
- 
+  void set_value(const double& value);
+
   /// Provides access to the underlying C GObject.
   PangoAttrFloat*       gobj()       { return reinterpret_cast<PangoAttrFloat*>(gobject_); }
   /// Provides access to the underlying C GObject.
@@ -554,8 +552,8 @@ public:
   /** Gets the font description which is the value of the attribute.
    * @return The font description of the attribute.
    */
-   FontDescription get_desc() const;
- 
+  FontDescription get_desc() const;
+
   /** Sets the font description which is the value of the attribute.
    * @param desc The new font description for the attribute.
    */
@@ -594,23 +592,23 @@ public:
   /** Gets the ink rectangle to restrict to.
    * @return The ink rectangle of the attribute.
    */
-   Rectangle get_ink_rect() const;
- 
+  Rectangle get_ink_rect() const;
+
   /** Gets the logical rectangle to restrict to.
    * @return The logical rectangle of the attribute.
    */
-   Rectangle get_logical_rect() const;
- 
+  Rectangle get_logical_rect() const;
+
   /** Sets the ink rectangle to restrict to.
    * @param value The new ink rectangle for the attribute.
    */
-   void set_ink_rect(const Rectangle& value);
- 
+  void set_ink_rect(const Rectangle& value);
+
   /** Sets the logical rectangle to restrict to.
    * @param value The new logical rectangle for the attribute.
    */
-   void set_logical_rect(const Rectangle& value);
- 
+  void set_logical_rect(const Rectangle& value);
+
   /// Provides access to the underlying C GObject.  
   PangoAttrShape*       gobj()       { return reinterpret_cast<PangoAttrShape*>(gobject_); }
   /// Provides access to the underlying C GObject.
diff --git a/libs/gtkmm2/pango/pangomm/attriter.cc b/libs/gtkmm2/pango/pangomm/attriter.cc
index 29c55a6a4d..71fa57052a 100644
--- a/libs/gtkmm2/pango/pangomm/attriter.cc
+++ b/libs/gtkmm2/pango/pangomm/attriter.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/attriter.h>
 #include <pangomm/private/attriter_p.h>
 
@@ -167,7 +166,7 @@ namespace Pango
 
 void AttrIter::get_range(int& start, int& end) const
 {
-pango_attr_iterator_range(const_cast<PangoAttrIterator*>(gobj()), &start, &end); 
+  pango_attr_iterator_range(const_cast<PangoAttrIterator*>(gobj()), &start, &end);
 }
 
 Attribute AttrIter::get_attribute(AttrType type) const
diff --git a/libs/gtkmm2/pango/pangomm/attriter.h b/libs/gtkmm2/pango/pangomm/attriter.h
index 9f840d71a7..ce654e92dd 100644
--- a/libs/gtkmm2/pango/pangomm/attriter.h
+++ b/libs/gtkmm2/pango/pangomm/attriter.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_ATTRITER_H
 #define _PANGOMM_ATTRITER_H
 
-
 #include <glibmm.h>
 
 /* attriter.h
diff --git a/libs/gtkmm2/pango/pangomm/attrlist.cc b/libs/gtkmm2/pango/pangomm/attrlist.cc
index 659ec91a68..deba57a453 100644
--- a/libs/gtkmm2/pango/pangomm/attrlist.cc
+++ b/libs/gtkmm2/pango/pangomm/attrlist.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/attrlist.h>
 #include <pangomm/private/attrlist_p.h>
 
@@ -38,11 +37,6 @@ AttrList::AttrList(const Glib::ustring& markup_text, gunichar accel_marker)
     gobject_ = 0;
 }
 
-AttrList::operator bool()
-{
-  return gobj() != 0;
-}
-
 AttrList::AttrList(const Glib::ustring& markup_text, gunichar accel_marker, Glib::ustring& text, gunichar& accel_char)
 {
   //initialize output parameters:
@@ -80,6 +74,7 @@ void AttrList::change(Attribute& attr)
  
 } /* namespace Pango */
 
+
 namespace
 {
 } // anonymous namespace
@@ -152,7 +147,7 @@ PangoAttrList* AttrList::gobj_copy() const
 
 void AttrList::splice(AttrList& other, int pos, int len)
 {
-pango_attr_list_splice(gobj(), (other).gobj(), pos, len); 
+  pango_attr_list_splice(gobj(), (other).gobj(), pos, len);
 }
 
 AttrIter AttrList::get_iter()
diff --git a/libs/gtkmm2/pango/pangomm/attrlist.h b/libs/gtkmm2/pango/pangomm/attrlist.h
index 10c2976d62..78d435e729 100644
--- a/libs/gtkmm2/pango/pangomm/attrlist.h
+++ b/libs/gtkmm2/pango/pangomm/attrlist.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_ATTRLIST_H
 #define _PANGOMM_ATTRLIST_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -44,8 +43,6 @@ namespace Pango
  *
  * Since the Pango::AttrList structure is stored as a linear list, it is not suitable for storing attributes for large amounts of text.
  * In general, you should not use a single Pango::AttrList for more than one paragraph of text.
- *
- * When obtaining an AttrList, you should check that it is valid. For instance, if(attrlist).
  */
 class AttrList
 {
@@ -113,9 +110,6 @@ public:
    */
   AttrList(const Glib::ustring& markup_text, gunichar accel_marker, Glib::ustring& text, gunichar& accel_char);
 
-  ///Tests whether the AttrList is valid.
-  operator bool();
-
   void insert(Attribute& attr);
    // hand code because we need to pass a copy of the attribute
   void insert_before(Attribute& attr);
@@ -125,9 +119,9 @@ public:
   
   /** This function splices attribute list @a other  into @a list .
    * This operation is equivalent to stretching every attribute
-   * that applies at position @a pos  in @a list  by an amount @a len ,
+   * applies at position @a pos  in @a list  by an amount @a len ,
    * and then calling pango_attr_list_change() with a copy
-   * of each attribute in @a other  in sequence (offset in position by @a pos ).
+   * of each attributes in @a other  in sequence (offset in position by @a pos ).
    * 
    * This operation proves useful for, for instance, inserting
    * a preedit string in the middle of an edit buffer.
@@ -184,6 +178,5 @@ class Value<Pango::AttrList> : public Glib::Value_Boxed<Pango::AttrList>
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_ATTRLIST_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/cairofontmap.cc b/libs/gtkmm2/pango/pangomm/cairofontmap.cc
deleted file mode 100644
index 30089936fd..0000000000
--- a/libs/gtkmm2/pango/pangomm/cairofontmap.cc
+++ /dev/null
@@ -1,163 +0,0 @@
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-
-#include <pangomm/cairofontmap.h>
-#include <pangomm/private/cairofontmap_p.h>
-
-// -*- c++ -*-
-/* $Id: cairofontmap.ccg,v 1.1 2006/05/30 17:14:21 murrayc Exp $ */
-
-/* 
- *
- * Copyright 2001      The gtkmm 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 <pangomm/context.h>
-#include <pango/pangocairo.h>
-
-namespace Pango
-{
-
-} /* namespace Pango */
-
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Pango::CairoFontMap> wrap(PangoCairoFontMap* object, bool take_copy)
-{
-  return Glib::RefPtr<Pango::CairoFontMap>( dynamic_cast<Pango::CairoFontMap*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
-  //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} // namespace Glib
-
-
-namespace Pango
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Interface_Class& CairoFontMap_Class::init()
-{
-  if(!gtype_) // create the GType if necessary
-  {
-    // Glib::Interface_Class has to know the interface init function
-    // in order to add interfaces to implementing types.
-    class_init_func_ = &CairoFontMap_Class::iface_init_function;
-
-    // We can not derive from another interface, and it is not necessary anyway.
-    gtype_ = pango_cairo_font_map_get_type();
-  }
-
-  return *this;
-}
-
-void CairoFontMap_Class::iface_init_function(void* g_iface, void*)
-{
-  BaseClassType *const klass = static_cast<BaseClassType*>(g_iface);
-
-  //This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
-  //This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
-  g_assert(klass != 0); 
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-}
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-Glib::ObjectBase* CairoFontMap_Class::wrap_new(GObject* object)
-{
-  return new CairoFontMap((PangoCairoFontMap*)(object));
-}
-
-
-/* The implementation: */
-
-CairoFontMap::CairoFontMap()
-:
-  Glib::Interface(cairofontmap_class_.init())
-{}
-
-CairoFontMap::CairoFontMap(PangoCairoFontMap* castitem)
-:
-  Glib::Interface((GObject*)(castitem))
-{}
-
-CairoFontMap::~CairoFontMap()
-{}
-
-// static
-void CairoFontMap::add_interface(GType gtype_implementer)
-{
-  cairofontmap_class_.init().add_interface(gtype_implementer);
-}
-
-CairoFontMap::CppClassType CairoFontMap::cairofontmap_class_; // initialize static member
-
-GType CairoFontMap::get_type()
-{
-  return cairofontmap_class_.init().get_type();
-}
-
-GType CairoFontMap::get_base_type()
-{
-  return pango_cairo_font_map_get_type();
-}
-
-
-void CairoFontMap::set_resolution(double dpi)
-{
-pango_cairo_font_map_set_resolution(gobj(), dpi); 
-}
-
-double CairoFontMap::get_resolution() const
-{
-  return pango_cairo_font_map_get_resolution(const_cast<PangoCairoFontMap*>(gobj()));
-}
-
-Glib::RefPtr<Context> CairoFontMap::create_context()
-{
-  return Glib::wrap(pango_cairo_font_map_create_context(gobj()));
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
-} // namespace Pango
-
-
diff --git a/libs/gtkmm2/pango/pangomm/cairofontmap.h b/libs/gtkmm2/pango/pangomm/cairofontmap.h
deleted file mode 100644
index 9dcce07823..0000000000
--- a/libs/gtkmm2/pango/pangomm/cairofontmap.h
+++ /dev/null
@@ -1,164 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _PANGOMM_CAIROFONTMAP_H
-#define _PANGOMM_CAIROFONTMAP_H
-
-
-#include <glibmm.h>
-
-/* $Id: cairofontmap.hg,v 1.1 2006/05/30 17:14:21 murrayc Exp $ */
-
-/* fontmap.h
- *
- * Copyright 2001      The gtkmm 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/interface.h>
-#include <pangomm/context.h>
-#include <pango/pangocairo.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _PangoCairoFontMapIface PangoCairoFontMapIface;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _PangoCairoFontMap PangoCairoFontMap;
-typedef struct _PangoCairoFontMapClass PangoCairoFontMapClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Pango
-{ class CairoFontMap_Class; } // namespace Pango
-namespace Pango
-{
-
-class Context;
-
-/** A Pango::CairoFontMap represents the set of fonts available for a particular rendering system.
- */
-
-class CairoFontMap : public Glib::Interface
-{
-   
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
-  typedef CairoFontMap CppObjectType;
-  typedef CairoFontMap_Class CppClassType;
-  typedef PangoCairoFontMap BaseObjectType;
-  typedef PangoCairoFontMapIface BaseClassType;
-
-private:
-  friend class CairoFontMap_Class;
-  static CppClassType cairofontmap_class_;
-
-  // noncopyable
-  CairoFontMap(const CairoFontMap&);
-  CairoFontMap& operator=(const CairoFontMap&);
-
-protected:
-  CairoFontMap(); // you must derive from this class
-  explicit CairoFontMap(PangoCairoFontMap* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
-  virtual ~CairoFontMap();
-
-  static void add_interface(GType gtype_implementer);
-
-#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 GObject.
-  PangoCairoFontMap*       gobj()       { return reinterpret_cast<PangoCairoFontMap*>(gobject_); }
-
-  ///Provides access to the underlying C GObject.  
-  const PangoCairoFontMap* gobj() const { return reinterpret_cast<PangoCairoFontMap*>(gobject_); }
-
-private:
-
-
-public:
-  //_WRAP_METHOD(static Glib::RefPtr<PangoFontMap> get_default(), pango_cairo_font_map_get_default) //TODO: ref this?
-
-  
-  /** Sets the resolution for the fontmap. This is a scale factor between
-   * points specified in a Pango::FontDescription and Cairo units. The
-   * default value is 96, meaning that a 10 point font will be 13
-   * units high. (10 * 96. / 72. = 13.3).
-   * 
-   * Since: 1.10
-   * @param dpi The resolution in "dots per inch". (Physical inches aren't actually
-   * involved; the terminology is conventional.).
-   */
-  void set_resolution(double dpi);
-  
-  /** Gets the resolutions for the fontmap. See pango_cairo_font_map_set_resolution.
-   * @return The resolution in "dots per inch"
-   * 
-   * Since: 1.10.
-   */
-  double get_resolution() const;
-  
-  /** Create a Pango::Context for the given fontmap.
-   * @return The newly created context; free with Glib::object_unref().
-   * 
-   * Since: 1.10.
-   */
-  Glib::RefPtr<Context> create_context();
-
-
-public:
-
-public:
-  //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-protected:
-  //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-
-};
-
-} /* namespace Pango */
-
-
-namespace Glib
-{
-  /** @relates Pango::CairoFontMap
-   * @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<Pango::CairoFontMap> wrap(PangoCairoFontMap* object, bool take_copy = false);
-
-} // namespace Glib
-
-
-#endif /* _PANGOMM_CAIROFONTMAP_H */
-
diff --git a/libs/gtkmm2/pango/pangomm/color.cc b/libs/gtkmm2/pango/pangomm/color.cc
index 50c8d2e2eb..946d7fcc37 100644
--- a/libs/gtkmm2/pango/pangomm/color.cc
+++ b/libs/gtkmm2/pango/pangomm/color.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/color.h>
 #include <pangomm/private/color_p.h>
 
@@ -38,6 +37,7 @@ Color::operator bool()
 
 } /* namespace Pango */
 
+
 namespace
 {
 } // anonymous namespace
@@ -83,36 +83,36 @@ Color::Color(const PangoColor* gobject)
 }
 
 
- guint16 Color::get_red() const
+guint16 Color::get_red() const
 {
   return gobj()->red;
 }
- 
- guint16 Color::get_green() const
+
+guint16 Color::get_green() const
 {
   return gobj()->green;
 }
- 
- guint16 Color::get_blue() const
+
+guint16 Color::get_blue() const
 {
   return gobj()->blue;
 }
- 
- void Color::set_red(const guint16& value)
+
+void Color::set_red(const guint16& value)
 {
   gobj()->red = value;
 }
- 
- void Color::set_green(const guint16& value)
+
+void Color::set_green(const guint16& value)
 {
   gobj()->green = value;
 }
- 
- void Color::set_blue(const guint16& value)
+
+void Color::set_blue(const guint16& value)
 {
   gobj()->blue = value;
 }
- 
+
 bool Color::parse(const Glib::ustring& spec)
 {
   return pango_color_parse(gobj(), spec.c_str());
diff --git a/libs/gtkmm2/pango/pangomm/color.h b/libs/gtkmm2/pango/pangomm/color.h
index ac31d223f1..07ce119896 100644
--- a/libs/gtkmm2/pango/pangomm/color.h
+++ b/libs/gtkmm2/pango/pangomm/color.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_COLOR_H
 #define _PANGOMM_COLOR_H
 
-
 #include <glibmm.h>
 
 /* Copyright (C) 2002 The gtkmm Development Team
@@ -65,33 +64,33 @@ public:
   /** Gets the red component of the color.
    * @return The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
    */
-   guint16 get_red() const;
- 
+  guint16 get_red() const;
+
   /** Gets the green component of the color.
    * @return The green component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
    */
-   guint16 get_green() const;
- 
+  guint16 get_green() const;
+
   /** Gets the blue component of the color.
    * @return The blue component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
    */
-   guint16 get_blue() const;
- 
+  guint16 get_blue() const;
+
   /** Sets the red component of the color.
    * @param value The red component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
    */
-   void set_red(const guint16& value);
- 
+  void set_red(const guint16& value);
+
   /** Sets the green component of the color.
    * @param value The green component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
    */
-   void set_green(const guint16& value);
- 
+  void set_green(const guint16& value);
+
   /** Sets the blue component of the color.
    * @param value The blue component of the color. This is a value between 0 and 65535, with 65535 indicating full intensity.
    */
-   void set_blue(const guint16& value);
- 
+  void set_blue(const guint16& value);
+
   
   /** Fill in the fields of a color from a string specification. The
    * string can either one of a large set of standard names. (Taken
@@ -135,6 +134,5 @@ class Value<Pango::Color> : public Glib::Value_Boxed<Pango::Color>
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_COLOR_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/context.cc b/libs/gtkmm2/pango/pangomm/context.cc
index 813f79c8f8..5acd2cc9cf 100644
--- a/libs/gtkmm2/pango/pangomm/context.cc
+++ b/libs/gtkmm2/pango/pangomm/context.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/context.h>
 #include <pangomm/private/context_p.h>
 
@@ -28,9 +27,6 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <pango/pangocairo.h>
-#include <pango/pango-types.h> //For PANGO_MATRIX_INIT
-
 namespace Pango
 {
 
@@ -69,23 +65,6 @@ ListHandle_Item Context::itemize(const Glib::ustring& text, int start_index, int
       Glib::OWNERSHIP_DEEP);
 }
 
-void Context::update_from_cairo_context(const Cairo::RefPtr<Cairo::Context>& context)
-{
-  pango_cairo_update_context(context->cobj(), gobj());
-}
-
-Matrix Context::get_matrix() const
-{
-  const PangoMatrix* matrix = pango_context_get_matrix(const_cast<PangoContext*>(gobj()));
-  if(matrix)
-    return *matrix;
-  else
-  {
-    PangoMatrix identity_transform = PANGO_MATRIX_INIT;
-    return identity_transform;
-  }
-}
-
 } /* namespace Pango */
 
 
@@ -143,19 +122,8 @@ void Context_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Context_Class::wrap_new(GObject* object)
 {
@@ -232,7 +200,7 @@ FontMetrics Context::get_metrics(const FontDescription& desc, const Language& la
 
 void Context::set_font_description(const FontDescription& desc)
 {
-pango_context_set_font_description(gobj(), (desc).gobj()); 
+  pango_context_set_font_description(gobj(), (desc).gobj());
 }
 
 FontDescription Context::get_font_description() const
@@ -247,12 +215,12 @@ Language Context::get_language() const
 
 void Context::set_language(const Language& language)
 {
-pango_context_set_language(gobj(), const_cast<PangoLanguage*>((language).gobj())); 
+  pango_context_set_language(gobj(), const_cast<PangoLanguage*>((language).gobj()));
 }
 
 void Context::set_base_dir(Direction direction)
 {
-pango_context_set_base_dir(gobj(), ((PangoDirection)(direction))); 
+  pango_context_set_base_dir(gobj(), ((PangoDirection)(direction)));
 }
 
 Direction Context::get_base_dir() const
@@ -262,37 +230,10 @@ Direction Context::get_base_dir() const
 
 void Context::set_matrix(const Matrix& matrix)
 {
-pango_context_set_matrix(gobj(), &(matrix)); 
-}
-
-void Context::set_cairo_font_options(const Cairo::FontOptions& options)
-{
-pango_cairo_context_set_font_options(gobj(), (options).cobj()); 
-}
-
-Cairo::FontOptions Context::get_font_options() const
-{
-  return Cairo::FontOptions(const_cast< cairo_font_options_t*>(pango_cairo_context_get_font_options(const_cast<PangoContext*>(gobj()))), false /* take_copy */);
-}
-
-void Context::set_resolution(double dpi)
-{
-pango_cairo_context_set_resolution(gobj(), dpi); 
-}
-
-double Context::get_resolution() const
-{
-  return pango_cairo_context_get_resolution(const_cast<PangoContext*>(gobj()));
+  pango_context_set_matrix(gobj(), &(matrix));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Pango
 
 
diff --git a/libs/gtkmm2/pango/pangomm/context.h b/libs/gtkmm2/pango/pangomm/context.h
index 3e8a2f947b..6ce379ff89 100644
--- a/libs/gtkmm2/pango/pangomm/context.h
+++ b/libs/gtkmm2/pango/pangomm/context.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_CONTEXT_H
 #define _PANGOMM_CONTEXT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -39,8 +38,6 @@
 #include <pangomm/attrlist.h>
 #include <pangomm/types.h> //For Matrix
 #include <pango/pango-context.h>
-#include <cairomm/context.h>
-#include <cairomm/fontoptions.h>
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -288,9 +285,7 @@ public:
    * (No matrix set is the same as setting the identity matrix.).
    */
   void set_matrix(const Matrix& matrix);
-
-  Matrix get_matrix() const;
-  
+  //TODO: _WRAP_METHOD(Matrix get_matrix() const, pango_context_get_matrix)
 
   /** Breaks a piece of text into segments with consistent directional level and shaping engine.
    * Each byte of @a text will be contained in exactly one of the items in the returned list.
@@ -322,43 +317,16 @@ public:
   ListHandle_Item itemize(const Glib::ustring& text, int start_index, int length,
                           const AttrList& attrs, AttrIter& cached_iter) const;
 
-  /** Updates a Pango Context previously created for use with Cairo to
-   * match the current transformation and target surface of a Cairo
-   * Context. If any layouts have been created for the context,
-   * it's necessary to call Pango::Layout::context_changed() on those
-   * layouts.
-   *
-   * @param context A Cairo context, from CairoFontMap::create_context().
-   */
-  void update_from_cairo_context(const Cairo::RefPtr<Cairo::Context>& context);
-
-
-  void set_cairo_font_options(const Cairo::FontOptions& options);
-
- 
-  Cairo::FontOptions get_font_options() const;
-
-  
-  void set_resolution(double dpi);
-  
-  double get_resolution() const;
-
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/coverage.cc b/libs/gtkmm2/pango/pangomm/coverage.cc
index b5b88afd10..e755994012 100644
--- a/libs/gtkmm2/pango/pangomm/coverage.cc
+++ b/libs/gtkmm2/pango/pangomm/coverage.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/coverage.h>
 #include <pangomm/private/coverage_p.h>
 
@@ -41,6 +40,7 @@ Glib::ArrayHandle<unsigned char> Coverage::to_bytes() const
 
 } /* namespace Pango */
 
+
 namespace
 {
 } // anonymous namespace
@@ -130,7 +130,6 @@ Glib::RefPtr<Coverage> Coverage::create(const guchar* bytes, int n_bytes)
   return Glib::wrap(pango_coverage_from_bytes(const_cast<guchar*>(bytes), n_bytes));
 }
 
-
 CoverageLevel Coverage::get(int index) const
 {
   return ((CoverageLevel)(pango_coverage_get(const_cast<PangoCoverage*>(gobj()), index)));
@@ -138,12 +137,12 @@ CoverageLevel Coverage::get(int index) const
 
 void Coverage::set(int index, CoverageLevel level)
 {
-pango_coverage_set(gobj(), index, ((PangoCoverageLevel)(level))); 
+  pango_coverage_set(gobj(), index, ((PangoCoverageLevel)(level)));
 }
 
 void Coverage::max(const Glib::RefPtr<Coverage>& other) const
 {
-pango_coverage_max(const_cast<PangoCoverage*>(gobj()), Glib::unwrap(other)); 
+  pango_coverage_max(const_cast<PangoCoverage*>(gobj()), Glib::unwrap(other));
 }
 
 
diff --git a/libs/gtkmm2/pango/pangomm/coverage.h b/libs/gtkmm2/pango/pangomm/coverage.h
index 30e4ec608e..eebbffd628 100644
--- a/libs/gtkmm2/pango/pangomm/coverage.h
+++ b/libs/gtkmm2/pango/pangomm/coverage.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_COVERAGE_H
 #define _PANGOMM_COVERAGE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -166,6 +165,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_COVERAGE_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/font.cc b/libs/gtkmm2/pango/pangomm/font.cc
index 4df6f821bd..b126931536 100644
--- a/libs/gtkmm2/pango/pangomm/font.cc
+++ b/libs/gtkmm2/pango/pangomm/font.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/font.h>
 #include <pangomm/private/font_p.h>
 
@@ -27,8 +26,6 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <pangomm/fontmap.h>
-
 namespace Pango
 {
 
@@ -102,19 +99,8 @@ void Font_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Font_Class::wrap_new(GObject* object)
 {
@@ -162,11 +148,6 @@ FontDescription Font::describe() const
   return FontDescription((pango_font_describe(const_cast<PangoFont*>(gobj()))));
 }
 
-FontDescription Font::describe_with_absolute_size() const
-{
-  return FontDescription((pango_font_describe_with_absolute_size(const_cast<PangoFont*>(gobj()))));
-}
-
 Glib::RefPtr<Coverage> Font::get_coverage(const Language& language) const
 {
   return Glib::wrap(pango_font_get_coverage(const_cast<PangoFont*>(gobj()), const_cast<PangoLanguage*>((language).gobj())));
@@ -179,26 +160,9 @@ FontMetrics Font::get_metrics(const Language& language) const
 
 void Font::get_glyph_extents(Glyph glyph, Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_font_get_glyph_extents(const_cast<PangoFont*>(gobj()), glyph, (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_font_get_glyph_extents(const_cast<PangoFont*>(gobj()), glyph, (ink_rect).gobj(), (logical_rect).gobj());
 }
 
-Glib::RefPtr<FontMap> Font::get_font_map()
-{
-  return Glib::wrap(pango_font_get_font_map(gobj()));
-}
-
-Glib::RefPtr<const FontMap> Font::get_font_map() const
-{
-  return const_cast<Font*>(this)->get_font_map();
-}
-
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 } // namespace Pango
 
diff --git a/libs/gtkmm2/pango/pangomm/font.h b/libs/gtkmm2/pango/pangomm/font.h
index ab7a221332..6aa53a1629 100644
--- a/libs/gtkmm2/pango/pangomm/font.h
+++ b/libs/gtkmm2/pango/pangomm/font.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_FONT_H
 #define _PANGOMM_FONT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -58,9 +57,6 @@ const double SCALE_LARGE    = 1.2;
 const double SCALE_X_LARGE  = 1.4399999999999;
 const double SCALE_XX_LARGE = 1.728;
 
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-class FontMap;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
 
 /** A Pango::Font is used to represent a font in a rendering-system-independent matter.
  */
@@ -118,8 +114,6 @@ public:
    */
   FontDescription describe() const;
   
-  FontDescription describe_with_absolute_size() const;
-  
   /** Computes the coverage map for a given font and language tag.
    * @param language The language tag.
    * @return A newly-allocated Pango::Coverage object.
@@ -156,17 +150,6 @@ public:
    */
   void get_glyph_extents(Glyph glyph, Rectangle& ink_rect, Rectangle& logical_rect) const;
 
-  
-  /** Gets the font map for which the font was created.
-   * @return The Pango::FontMap for the font.
-   */
-  Glib::RefPtr<FontMap> get_font_map();
-  
-  /** Gets the font map for which the font was created.
-   * @return The Pango::FontMap for the font.
-   */
-  Glib::RefPtr<const FontMap> get_font_map() const;
-
   /** Get the ink extents of a glyph within the font.
    * @param glyph The glyph index.
    * @return The extents of the glyph as drawn.
@@ -184,17 +167,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/fontdescription.cc b/libs/gtkmm2/pango/pangomm/fontdescription.cc
index dc5bd3ef94..af866dc9cb 100644
--- a/libs/gtkmm2/pango/pangomm/fontdescription.cc
+++ b/libs/gtkmm2/pango/pangomm/fontdescription.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/fontdescription.h>
 #include <pangomm/private/fontdescription_p.h>
 
@@ -148,7 +147,7 @@ guint FontDescription::hash() const
 
 void FontDescription::set_family(const Glib::ustring& family)
 {
-pango_font_description_set_family(gobj(), family.c_str()); 
+  pango_font_description_set_family(gobj(), family.c_str());
 }
 
 Glib::ustring FontDescription::get_family() const
@@ -158,7 +157,7 @@ Glib::ustring FontDescription::get_family() const
 
 void FontDescription::set_style(Style style)
 {
-pango_font_description_set_style(gobj(), ((PangoStyle)(style))); 
+  pango_font_description_set_style(gobj(), ((PangoStyle)(style)));
 }
 
 Style FontDescription::get_style() const
@@ -168,7 +167,7 @@ Style FontDescription::get_style() const
 
 void FontDescription::set_variant(Variant variant)
 {
-pango_font_description_set_variant(gobj(), ((PangoVariant)(variant))); 
+  pango_font_description_set_variant(gobj(), ((PangoVariant)(variant)));
 }
 
 Variant FontDescription::get_variant() const
@@ -178,7 +177,7 @@ Variant FontDescription::get_variant() const
 
 void FontDescription::set_weight(Weight weight)
 {
-pango_font_description_set_weight(gobj(), ((PangoWeight)(weight))); 
+  pango_font_description_set_weight(gobj(), ((PangoWeight)(weight)));
 }
 
 Weight FontDescription::get_weight() const
@@ -188,7 +187,7 @@ Weight FontDescription::get_weight() const
 
 void FontDescription::set_stretch(Stretch stretch)
 {
-pango_font_description_set_stretch(gobj(), ((PangoStretch)(stretch))); 
+  pango_font_description_set_stretch(gobj(), ((PangoStretch)(stretch)));
 }
 
 Stretch FontDescription::get_stretch() const
@@ -198,7 +197,7 @@ Stretch FontDescription::get_stretch() const
 
 void FontDescription::set_size(int size)
 {
-pango_font_description_set_size(gobj(), size); 
+  pango_font_description_set_size(gobj(), size);
 }
 
 int FontDescription::get_size() const
@@ -206,16 +205,6 @@ int FontDescription::get_size() const
   return pango_font_description_get_size(const_cast<PangoFontDescription*>(gobj()));
 }
 
-void FontDescription::set_absolute_size(double size)
-{
-pango_font_description_set_absolute_size(gobj(), size); 
-}
-
-bool FontDescription::get_size_is_absolute() const
-{
-  return pango_font_description_get_size_is_absolute(const_cast<PangoFontDescription*>(gobj()));
-}
-
 FontMask FontDescription::get_set_fields() const
 {
   return ((FontMask)(pango_font_description_get_set_fields(const_cast<PangoFontDescription*>(gobj()))));
@@ -223,12 +212,12 @@ FontMask FontDescription::get_set_fields() const
 
 void FontDescription::unset_fields(FontMask to_unset)
 {
-pango_font_description_unset_fields(gobj(), ((PangoFontMask)(to_unset))); 
+  pango_font_description_unset_fields(gobj(), ((PangoFontMask)(to_unset)));
 }
 
 void FontDescription::merge(const FontDescription& desc_to_merge, bool replace_existing)
 {
-pango_font_description_merge(gobj(), (desc_to_merge).gobj(), static_cast<int>(replace_existing)); 
+  pango_font_description_merge(gobj(), (desc_to_merge).gobj(), static_cast<int>(replace_existing));
 }
 
 bool FontDescription::better_match(const FontDescription& old_match, const FontDescription& new_match) const
diff --git a/libs/gtkmm2/pango/pangomm/fontdescription.h b/libs/gtkmm2/pango/pangomm/fontdescription.h
index 9d2def1537..1c51be840c 100644
--- a/libs/gtkmm2/pango/pangomm/fontdescription.h
+++ b/libs/gtkmm2/pango/pangomm/fontdescription.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_FONTDESCRIPTION_H
 #define _PANGOMM_FONTDESCRIPTION_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -146,7 +145,6 @@ enum Weight
   WEIGHT_ULTRALIGHT = 200,
   WEIGHT_LIGHT = 300,
   WEIGHT_NORMAL = 400,
-  WEIGHT_SEMIBOLD = 600,
   WEIGHT_BOLD = 700,
   WEIGHT_ULTRABOLD = 800,
   WEIGHT_HEAVY = 900
@@ -416,26 +414,6 @@ public:
    */
   int get_size() const;
   
-  /** Sets the size field of a font description, in device units. This is mutually
-   * exclusive with pango_font_description_set_size().
-   * 
-   * Since: 1.8
-   * @param size The new size, in pango units. There are Pango::SCALE Pango units in one
-   * device unit. For an output backend where a device unit is a pixel, a @a size 
-   * value of 10 * PANGO_SCALE gives a 10 pixel font.
-   */
-  void set_absolute_size(double size);
-  
-  /** Determines whether the size of the font is in points or device units.
-   * See pango_font_description_set_size() and pango_font_description_set_absolute_size().
-   * @return Whether the the size for the font description is in
-   * points or device units.  Use pango_font_description_get_set_fields() to
-   * find out if the size field of the font description was explicitely set or not.
-   * 
-   * Since: 1.8.
-   */
-  bool get_size_is_absolute() const;
-  
   /** Determines which fields in a font description have been set.
    * @return A bitmask with bits set corresponding to the
    * fields in @a desc  that have been set.
@@ -547,6 +525,5 @@ class Value<Pango::FontDescription> : public Glib::Value_Boxed<Pango::FontDescri
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_FONTDESCRIPTION_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/fontface.cc b/libs/gtkmm2/pango/pangomm/fontface.cc
index ea64503e78..44c087aaef 100644
--- a/libs/gtkmm2/pango/pangomm/fontface.cc
+++ b/libs/gtkmm2/pango/pangomm/fontface.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/fontface.h>
 #include <pangomm/private/fontface_p.h>
 
@@ -89,19 +88,8 @@ void FontFace_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FontFace_Class::wrap_new(GObject* object)
 {
@@ -155,13 +143,6 @@ Glib::ustring FontFace::get_name() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Pango
 
 
diff --git a/libs/gtkmm2/pango/pangomm/fontface.h b/libs/gtkmm2/pango/pangomm/fontface.h
index 7eea486ad5..64b0317c7c 100644
--- a/libs/gtkmm2/pango/pangomm/fontface.h
+++ b/libs/gtkmm2/pango/pangomm/fontface.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_FONTFACE_H
 #define _PANGOMM_FONTFACE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -125,17 +124,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/fontfamily.cc b/libs/gtkmm2/pango/pangomm/fontfamily.cc
index 12b164645b..da7f0be452 100644
--- a/libs/gtkmm2/pango/pangomm/fontfamily.cc
+++ b/libs/gtkmm2/pango/pangomm/fontfamily.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/fontfamily.h>
 #include <pangomm/private/fontfamily_p.h>
 
@@ -90,19 +89,8 @@ void FontFamily_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FontFamily_Class::wrap_new(GObject* object)
 {
@@ -156,13 +144,6 @@ bool FontFamily::is_monospace() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Pango
 
 
diff --git a/libs/gtkmm2/pango/pangomm/fontfamily.h b/libs/gtkmm2/pango/pangomm/fontfamily.h
index 363cb9644e..f763866a19 100644
--- a/libs/gtkmm2/pango/pangomm/fontfamily.h
+++ b/libs/gtkmm2/pango/pangomm/fontfamily.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_FONTFAMILY_H
 #define _PANGOMM_FONTFAMILY_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -131,17 +130,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/fontmap.cc b/libs/gtkmm2/pango/pangomm/fontmap.cc
index a54704503a..1e5caa8ab4 100644
--- a/libs/gtkmm2/pango/pangomm/fontmap.cc
+++ b/libs/gtkmm2/pango/pangomm/fontmap.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/fontmap.h>
 #include <pangomm/private/fontmap_p.h>
 
@@ -94,19 +93,8 @@ void FontMap_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* FontMap_Class::wrap_new(GObject* object)
 {
@@ -160,13 +148,6 @@ Glib::RefPtr<Fontset> FontMap::load_fontset(const Glib::RefPtr<Context>& context
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Pango
 
 
diff --git a/libs/gtkmm2/pango/pangomm/fontmap.h b/libs/gtkmm2/pango/pangomm/fontmap.h
index 575186607f..c05fe7cc44 100644
--- a/libs/gtkmm2/pango/pangomm/fontmap.h
+++ b/libs/gtkmm2/pango/pangomm/fontmap.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_FONTMAP_H
 #define _PANGOMM_FONTMAP_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -127,17 +126,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/fontmetrics.cc b/libs/gtkmm2/pango/pangomm/fontmetrics.cc
index a70dae136b..d9ba904f5b 100644
--- a/libs/gtkmm2/pango/pangomm/fontmetrics.cc
+++ b/libs/gtkmm2/pango/pangomm/fontmetrics.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/fontmetrics.h>
 #include <pangomm/private/fontmetrics_p.h>
 
@@ -27,6 +26,7 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+
 namespace
 {
 } // anonymous namespace
diff --git a/libs/gtkmm2/pango/pangomm/fontmetrics.h b/libs/gtkmm2/pango/pangomm/fontmetrics.h
index 49369bf225..8b66669f81 100644
--- a/libs/gtkmm2/pango/pangomm/fontmetrics.h
+++ b/libs/gtkmm2/pango/pangomm/fontmetrics.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_FONTMETRICS_H
 #define _PANGOMM_FONTMETRICS_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -184,6 +183,5 @@ class Value<Pango::FontMetrics> : public Glib::Value_Boxed<Pango::FontMetrics>
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_FONTMETRICS_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/fontset.cc b/libs/gtkmm2/pango/pangomm/fontset.cc
index 4888102356..2d684bde16 100644
--- a/libs/gtkmm2/pango/pangomm/fontset.cc
+++ b/libs/gtkmm2/pango/pangomm/fontset.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/fontset.h>
 #include <pangomm/private/fontset_p.h>
 
@@ -26,17 +25,16 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-static gboolean fontset_foreach_callback(PangoFontset* /* fontset */, PangoFont* font, gpointer data)
+namespace { //anonymous
+
+gboolean fontset_foreach_callback(PangoFontset* /* fontset */, PangoFont* font, gpointer data)
 {
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   try
   {
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
     Pango::Fontset::ForeachSlot& slot = *static_cast<Pango::Fontset::ForeachSlot*>(data);
     Glib::RefPtr<Pango::Font> cppFont = Glib::wrap(font, true /* take_copy */);
-
+    
     return slot(cppFont);
-  #ifdef GLIBMM_EXCEPTIONS_ENABLED
   }
   catch(...)
   {
@@ -44,10 +42,11 @@ static gboolean fontset_foreach_callback(PangoFontset* /* fontset */, PangoFont*
   }
 
   return false; //arbitrary default
-  #endif //GLIBMM_EXCEPTIONS_ENABLED
 }
 
 
+} //anonymous namespace
+
 namespace Pango
 {
 
@@ -58,6 +57,7 @@ void Fontset::foreach(const ForeachSlot& slot)
            
 } //namespace
 
+
 namespace
 {
 } // anonymous namespace
@@ -106,19 +106,8 @@ void Fontset_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Fontset_Class::wrap_new(GObject* object)
 {
@@ -172,13 +161,6 @@ FontMetrics Fontset::get_metrics() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Pango
 
 
diff --git a/libs/gtkmm2/pango/pangomm/fontset.h b/libs/gtkmm2/pango/pangomm/fontset.h
index eb8a1d1ea3..d3baddfbea 100644
--- a/libs/gtkmm2/pango/pangomm/fontset.h
+++ b/libs/gtkmm2/pango/pangomm/fontset.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_FONTSET_H
 #define _PANGOMM_FONTSET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -117,7 +116,7 @@ public:
   /** Iterates through all the fonts in a fontset, calling @a slot for
    * each one. If @a slot returns true, that stops the iteration.
    *
-   * @since-1.4
+   * Since: 1.4
    *
    * @param slot Callback function
    */
@@ -128,17 +127,11 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/glyph.cc b/libs/gtkmm2/pango/pangomm/glyph.cc
index c68065705b..bf595ec5b0 100644
--- a/libs/gtkmm2/pango/pangomm/glyph.cc
+++ b/libs/gtkmm2/pango/pangomm/glyph.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/glyph.h>
 #include <pangomm/private/glyph_p.h>
 
@@ -92,6 +91,7 @@ const Pango::GlyphVisAttr& wrap(const PangoGlyphVisAttr* object)
 
 } //namespace Glib
 
+
 namespace
 {
 } // anonymous namespace
@@ -101,21 +101,21 @@ namespace Pango
 {
 
 
- Glyph GlyphInfo::get_glyph() const
+Glyph GlyphInfo::get_glyph() const
 {
   return gobj()->glyph;
 }
- 
- GlyphGeometry GlyphInfo::get_geometry() const
+
+GlyphGeometry GlyphInfo::get_geometry() const
 {
   return GlyphGeometry(&(gobj()->geometry));
 }
- 
- GlyphVisAttr GlyphInfo::get_attr() const
+
+GlyphVisAttr GlyphInfo::get_attr() const
 {
   return gobj()->attr;
 }
- 
+
 
 } // namespace Pango
 
@@ -124,21 +124,21 @@ namespace Pango
 {
 
 
- GlyphUnit GlyphGeometry::get_width() const
+GlyphUnit GlyphGeometry::get_width() const
 {
   return gobj()->width;
 }
- 
- GlyphUnit GlyphGeometry::get_x_offset() const
+
+GlyphUnit GlyphGeometry::get_x_offset() const
 {
   return gobj()->x_offset;
 }
- 
- GlyphUnit GlyphGeometry::get_y_offset() const
+
+GlyphUnit GlyphGeometry::get_y_offset() const
 {
   return gobj()->y_offset;
 }
- 
+
 
 } // namespace Pango
 
diff --git a/libs/gtkmm2/pango/pangomm/glyph.h b/libs/gtkmm2/pango/pangomm/glyph.h
index 5f61e19b9b..387999d306 100644
--- a/libs/gtkmm2/pango/pangomm/glyph.h
+++ b/libs/gtkmm2/pango/pangomm/glyph.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_GLYPH_H
 #define _PANGOMM_GLYPH_H
 
-
 #include <glibmm.h>
 
 /* glyph.h
@@ -69,18 +68,18 @@ public:
   /** Gets the glyph itself.
    * @return The glyph.
    */
-   Glyph get_glyph() const;
- 
+  Glyph get_glyph() const;
+
   /** Gets the positional information about the glyph.
    * @return A GylphGeometry object.
    */
-   GlyphGeometry get_geometry() const;
- 
+  GlyphGeometry get_geometry() const;
+
   /** Gets the visual attributes of the glyph.
    * @return A GlyphVisAttr structure.
    */
-   GlyphVisAttr get_attr() const;
- 
+  GlyphVisAttr get_attr() const;
+
 //I don't think that we need these set_* functions!
 //TODO: Who wrote this? Investigate. murrayc.
   /* Sets the glyph itself.
@@ -130,18 +129,18 @@ public:
   /** Gets the logical width to use for the character.
    * @return The logical width.
    */
-   GlyphUnit get_width() const;
- 
+  GlyphUnit get_width() const;
+
   /** Gets the horizontal offset from nominal character position.
    * @return The horizontal offset.
    */
-   GlyphUnit get_x_offset() const;
- 
+  GlyphUnit get_x_offset() const;
+
   /** Gets the vertical offset from nominal character position.
    * @return The vertical offset.
    */
-   GlyphUnit get_y_offset() const;
- 
+  GlyphUnit get_y_offset() const;
+
 //I don't think that we need these set_* functions!
   /* Sets the logical width to use for the character.
    * @param width The new logical width.
@@ -219,6 +218,5 @@ const Pango::GlyphGeometry& wrap(const PangoGlyphGeometry* object);
 
 } //namespace Glib
 
-
 #endif /* _PANGOMM_GLYPH_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/glyphstring.cc b/libs/gtkmm2/pango/pangomm/glyphstring.cc
index eb4d55b5d7..38ba283c70 100644
--- a/libs/gtkmm2/pango/pangomm/glyphstring.cc
+++ b/libs/gtkmm2/pango/pangomm/glyphstring.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/glyphstring.h>
 #include <pangomm/private/glyphstring_p.h>
 
@@ -27,7 +26,7 @@
  */
 
 #include <glibmm/utility.h>
-#include <pango/pangocairo.h>
+
 
 namespace Pango
 {
@@ -95,6 +94,7 @@ Glib::ArrayHandle<GlyphInfo> GlyphString::get_glyphs() const
 
 } //namespace Pango
 
+
 namespace
 {
 } // anonymous namespace
@@ -167,17 +167,17 @@ PangoGlyphString* GlyphString::gobj_copy() const
 
 void GlyphString::set_size(int new_len)
 {
-pango_glyph_string_set_size(gobj(), new_len); 
+  pango_glyph_string_set_size(gobj(), new_len);
 }
 
 void GlyphString::get_extents(const Glib::RefPtr<const Font>& font, Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_glyph_string_extents(const_cast<PangoGlyphString*>(gobj()), const_cast<PangoFont*>(Glib::unwrap<Font>(font)), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_glyph_string_extents(const_cast<PangoGlyphString*>(gobj()), const_cast<PangoFont*>(Glib::unwrap<Font>(font)), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 void GlyphString::get_extents(int start, int end, const Glib::RefPtr<const Font>& font, Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_glyph_string_extents_range(const_cast<PangoGlyphString*>(gobj()), start, end, const_cast<PangoFont*>(Glib::unwrap<Font>(font)), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_glyph_string_extents_range(const_cast<PangoGlyphString*>(gobj()), start, end, const_cast<PangoFont*>(Glib::unwrap<Font>(font)), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 
diff --git a/libs/gtkmm2/pango/pangomm/glyphstring.h b/libs/gtkmm2/pango/pangomm/glyphstring.h
index 9f8dcf520e..7313e41766 100644
--- a/libs/gtkmm2/pango/pangomm/glyphstring.h
+++ b/libs/gtkmm2/pango/pangomm/glyphstring.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_GLYPHSTRING_H
 #define _PANGOMM_GLYPHSTRING_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -30,7 +29,6 @@
 #include <pangomm/font.h>
 #include <pangomm/glyph.h>
 #include <pangomm/item.h>
-#include <cairomm/context.h>
 #include <pango/pango-glyph.h>
 #include <pango/pango-item.h> //For PangoAnalysis.
 
@@ -185,8 +183,6 @@ public:
    */
   Glib::ArrayHandle<GlyphInfo> get_glyphs() const;
 
-  //TODO: Wrap pango_cairo_glyph_string_path().
-
 
 };
 
@@ -223,6 +219,5 @@ class Value<Pango::GlyphString> : public Glib::Value_Boxed<Pango::GlyphString>
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_GLYPHSTRING_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/item.cc b/libs/gtkmm2/pango/pangomm/item.cc
index e120630df4..f798552e1b 100644
--- a/libs/gtkmm2/pango/pangomm/item.cc
+++ b/libs/gtkmm2/pango/pangomm/item.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/item.h>
 #include <pangomm/private/item_p.h>
 
@@ -138,7 +137,7 @@ namespace Pango
 {
 
 
- Glib::RefPtr<Font> Analysis::get_font()
+Glib::RefPtr<Font> Analysis::get_font()
 {
   Glib::RefPtr<Font> ref_ptr(Glib::wrap(gobj()->font));
 
@@ -157,17 +156,17 @@ Glib::RefPtr<const Font> Analysis::get_font() const
 
   return ref_ptr;
 }
- 
- guint8 Analysis::get_level() const
+
+guint8 Analysis::get_level() const
 {
   return gobj()->level;
 }
- 
- Language Analysis::get_language() const
+
+Language Analysis::get_language() const
 {
   return Language(gobj()->language);
 }
- 
+
 
 } // namespace Pango
 
@@ -181,21 +180,21 @@ Item Item::split(int split_index, int split_offset)
   return Item((pango_item_split(gobj(), split_index, split_offset)));
 }
 
- int Item::get_offset() const
+int Item::get_offset() const
 {
   return gobj()->offset;
 }
- 
- int Item::get_length() const
+
+int Item::get_length() const
 {
   return gobj()->length;
 }
- 
- int Item::get_num_chars() const
+
+int Item::get_num_chars() const
 {
   return gobj()->num_chars;
 }
- 
+
 
 } // namespace Pango
 
diff --git a/libs/gtkmm2/pango/pangomm/item.h b/libs/gtkmm2/pango/pangomm/item.h
index fd871f9273..3e58b9a069 100644
--- a/libs/gtkmm2/pango/pangomm/item.h
+++ b/libs/gtkmm2/pango/pangomm/item.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_ITEM_H
 #define _PANGOMM_ITEM_H
 
-
 #include <glibmm.h>
 
 /* Copyright (C) 2002 The gtkmm Development Team
@@ -65,19 +64,19 @@ public:
   /** Gets the font used to render this segment.
    * @return The font used to render this segment.
    */
-   Glib::RefPtr<Font> get_font();
+  Glib::RefPtr<Font> get_font();
   Glib::RefPtr<const Font> get_font() const;
- 
+
   /** Gets the bidrectional level for this segment.
    * @return The bidirectional level for this segment.
    */
-   guint8 get_level() const;
- 
+  guint8 get_level() const;
+
   /** Gets the language of this segment.
    * @return The language of this segment.
    */
-   Language get_language() const;
- 
+  Language get_language() const;
+
   /** Gets a list of non-font attributes for this segment.
    * @return A list of non-font attributes for this segment.
    */
@@ -150,18 +149,18 @@ public:
   /** Gets the offset of the segment from the beginning of the string in bytes.
    * @return The offset of the segment from the beginning of the string in bytes.
    */
-   int get_offset() const;
- 
+  int get_offset() const;
+
   /** Gets the length of the segment in bytes.
    * @return The length of the segment in bytes.
    */
-   int get_length() const;
- 
+  int get_length() const;
+
   /** Gets the length of the segment in characters.
    * @return The length of the semgment in characters.
    */
-   int get_num_chars() const;
- 
+  int get_num_chars() const;
+
   /** Gets the properties of the segment.
    * @return The properties of the segment.
    */
diff --git a/libs/gtkmm2/pango/pangomm/language.cc b/libs/gtkmm2/pango/pangomm/language.cc
index 120f6e7216..db2fd1fde4 100644
--- a/libs/gtkmm2/pango/pangomm/language.cc
+++ b/libs/gtkmm2/pango/pangomm/language.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/language.h>
 #include <pangomm/private/language_p.h>
 
@@ -70,6 +69,7 @@ Glib::ustring Language::get_string() const
 
 } /* namespace Pango */
 
+
 namespace
 {
 } // anonymous namespace
diff --git a/libs/gtkmm2/pango/pangomm/language.h b/libs/gtkmm2/pango/pangomm/language.h
index 9887f64bda..f4f762eb39 100644
--- a/libs/gtkmm2/pango/pangomm/language.h
+++ b/libs/gtkmm2/pango/pangomm/language.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_LANGUAGE_H
 #define _PANGOMM_LANGUAGE_H
 
-
 #include <glibmm.h>
 
 /* Copyright (C) 2002 The gtkmm Development Team
@@ -242,6 +241,5 @@ class Value<Pango::Language> : public Glib::Value_Boxed<Pango::Language>
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_LANGUAGE_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/layout.cc b/libs/gtkmm2/pango/pangomm/layout.cc
index 91fbeb1a6e..96d45e2037 100644
--- a/libs/gtkmm2/pango/pangomm/layout.cc
+++ b/libs/gtkmm2/pango/pangomm/layout.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/layout.h>
 #include <pangomm/private/layout_p.h>
 
@@ -27,8 +26,6 @@
  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <pango/pangocairo.h>
-
 namespace Pango
 {
 
@@ -37,16 +34,6 @@ Layout::Layout(const Glib::RefPtr<Context>& context)
   Glib::Object(G_OBJECT(pango_layout_new(context->gobj())))
 {}
 
-Glib::RefPtr<Layout> Layout::create(const Cairo::RefPtr<Cairo::Context>& context)
-{
-  return Glib::wrap( pango_cairo_create_layout(context->cobj()) );
-}
-
-void Layout::update_from_cairo_context(const Cairo::RefPtr<Cairo::Context>& context)
-{
-  pango_cairo_update_layout(context->cobj(), gobj());
-}
-
 void Layout::set_text(const Glib::ustring& text)
 {
   pango_layout_set_text(gobj(), text.c_str(), text.bytes());
@@ -131,13 +118,9 @@ void Layout::unset_font_description()
   pango_layout_set_font_description(gobj(), 0);
 }
 
-void Layout::add_to_cairo_context(const Cairo::RefPtr<Cairo::Context>& context)
-{
-  pango_cairo_layout_path(context->cobj(), gobj());
-}
-
 } /* namespace Pango */
 
+
 namespace
 {
 } // anonymous namespace
@@ -204,19 +187,8 @@ void Layout_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Layout_Class::wrap_new(GObject* object)
 {
@@ -272,15 +244,15 @@ Glib::RefPtr<Context> Layout::get_context() const
 {
 
   Glib::RefPtr<Context> retvalue = Glib::wrap(pango_layout_get_context(const_cast<PangoLayout*>(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 void Layout::set_attributes(AttrList& attrs)
 {
-pango_layout_set_attributes(gobj(), (attrs).gobj()); 
+  pango_layout_set_attributes(gobj(), (attrs).gobj());
 }
 
 AttrList Layout::get_attributes() const
@@ -295,17 +267,12 @@ Glib::ustring Layout::get_text() const
 
 void Layout::set_font_description(const FontDescription& desc)
 {
-pango_layout_set_font_description(gobj(), (desc).gobj()); 
-}
-
-FontDescription Layout::get_font_description() const
-{
-  return FontDescription(const_cast<PangoFontDescription*>(pango_layout_get_font_description(const_cast<PangoLayout*>(gobj()))));
+  pango_layout_set_font_description(gobj(), (desc).gobj());
 }
 
 void Layout::set_width(int width)
 {
-pango_layout_set_width(gobj(), width); 
+  pango_layout_set_width(gobj(), width);
 }
 
 int Layout::get_width() const
@@ -315,7 +282,7 @@ int Layout::get_width() const
 
 void Layout::set_wrap(WrapMode wrap)
 {
-pango_layout_set_wrap(gobj(), ((PangoWrapMode)(wrap))); 
+  pango_layout_set_wrap(gobj(), ((PangoWrapMode)(wrap)));
 }
 
 WrapMode Layout::get_wrap() const
@@ -325,7 +292,7 @@ WrapMode Layout::get_wrap() const
 
 void Layout::set_indent(int indent)
 {
-pango_layout_set_indent(gobj(), indent); 
+  pango_layout_set_indent(gobj(), indent);
 }
 
 int Layout::get_indent() const
@@ -335,7 +302,7 @@ int Layout::get_indent() const
 
 void Layout::set_spacing(int spacing)
 {
-pango_layout_set_spacing(gobj(), spacing); 
+  pango_layout_set_spacing(gobj(), spacing);
 }
 
 int Layout::get_spacing() const
@@ -345,7 +312,7 @@ int Layout::get_spacing() const
 
 void Layout::set_justify(bool justify)
 {
-pango_layout_set_justify(gobj(), static_cast<int>(justify)); 
+  pango_layout_set_justify(gobj(), static_cast<int>(justify));
 }
 
 bool Layout::get_justify() const
@@ -360,12 +327,12 @@ bool Layout::get_auto_dir() const
 
 void Layout::set_auto_dir(bool auto_dir)
 {
-pango_layout_set_auto_dir(gobj(), static_cast<int>(auto_dir)); 
+  pango_layout_set_auto_dir(gobj(), static_cast<int>(auto_dir));
 }
 
 void Layout::set_alignment(Alignment alignment)
 {
-pango_layout_set_alignment(gobj(), ((PangoAlignment)(alignment))); 
+  pango_layout_set_alignment(gobj(), ((PangoAlignment)(alignment)));
 }
 
 Alignment Layout::get_alignment() const
@@ -375,7 +342,7 @@ Alignment Layout::get_alignment() const
 
 void Layout::set_tabs(TabArray& tabs)
 {
-pango_layout_set_tabs(gobj(), (tabs).gobj()); 
+  pango_layout_set_tabs(gobj(), (tabs).gobj());
 }
 
 TabArray Layout::get_tabs() const
@@ -385,7 +352,7 @@ TabArray Layout::get_tabs() const
 
 void Layout::set_single_paragraph_mode(bool setting)
 {
-pango_layout_set_single_paragraph_mode(gobj(), static_cast<int>(setting)); 
+  pango_layout_set_single_paragraph_mode(gobj(), static_cast<int>(setting));
 }
 
 bool Layout::get_single_paragraph_mode() const
@@ -395,7 +362,7 @@ bool Layout::get_single_paragraph_mode() const
 
 void Layout::set_ellipsize(EllipsizeMode ellipsize)
 {
-pango_layout_set_ellipsize(gobj(), ((PangoEllipsizeMode)(ellipsize))); 
+  pango_layout_set_ellipsize(gobj(), ((PangoEllipsizeMode)(ellipsize)));
 }
 
 EllipsizeMode Layout::get_ellipsize() const
@@ -405,22 +372,17 @@ EllipsizeMode Layout::get_ellipsize() const
 
 void Layout::context_changed()
 {
-pango_layout_context_changed(gobj()); 
-}
-
-void Layout::index_to_line_x(int index_, bool trailing, int& line, int& x_pos) const
-{
-pango_layout_index_to_line_x(const_cast<PangoLayout*>(gobj()), index_, static_cast<int>(trailing), &line, &x_pos); 
+  pango_layout_context_changed(gobj());
 }
 
 void Layout::get_cursor_pos(int index, Rectangle& strong_pos, Rectangle& weak_pos) const
 {
-pango_layout_get_cursor_pos(const_cast<PangoLayout*>(gobj()), index, (strong_pos).gobj(), (weak_pos).gobj()); 
+  pango_layout_get_cursor_pos(const_cast<PangoLayout*>(gobj()), index, (strong_pos).gobj(), (weak_pos).gobj());
 }
 
 void Layout::move_cursor_visually(bool strong, int old_index, int old_trailing, int direction, int& new_index, int& new_trailing) const
 {
-pango_layout_move_cursor_visually(const_cast<PangoLayout*>(gobj()), static_cast<int>(strong), old_index, old_trailing, direction, &new_index, &new_trailing); 
+  pango_layout_move_cursor_visually(const_cast<PangoLayout*>(gobj()), static_cast<int>(strong), old_index, old_trailing, direction, &new_index, &new_trailing);
 }
 
 bool Layout::xy_to_index(int x, int y, int& index, int& trailing) const
@@ -430,22 +392,22 @@ bool Layout::xy_to_index(int x, int y, int& index, int& trailing) const
 
 void Layout::get_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_get_extents(const_cast<PangoLayout*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_get_extents(const_cast<PangoLayout*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 void Layout::get_pixel_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_get_pixel_extents(const_cast<PangoLayout*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_get_pixel_extents(const_cast<PangoLayout*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 void Layout::get_size(int& width, int& height) const
 {
-pango_layout_get_size(const_cast<PangoLayout*>(gobj()), &width, &height); 
+  pango_layout_get_size(const_cast<PangoLayout*>(gobj()), &width, &height);
 }
 
 void Layout::get_pixel_size(int& width, int& height) const
 {
-pango_layout_get_pixel_size(const_cast<PangoLayout*>(gobj()), &width, &height); 
+  pango_layout_get_pixel_size(const_cast<PangoLayout*>(gobj()), &width, &height);
 }
 
 int Layout::get_line_count() const
@@ -457,20 +419,20 @@ Glib::RefPtr<LayoutLine> Layout::get_line(int line)
 {
 
   Glib::RefPtr<LayoutLine> retvalue = Glib::wrap(pango_layout_get_line(gobj(), line));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 Glib::RefPtr<const LayoutLine> Layout::get_line(int line) const
 {
 
   Glib::RefPtr<const LayoutLine> retvalue = Glib::wrap(pango_layout_get_line(const_cast<PangoLayout*>(gobj()), line));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 SListHandle_LayoutLine Layout::get_lines()
@@ -484,13 +446,6 @@ SListHandle_ConstLayoutLine Layout::get_lines() const
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Pango
 
 
diff --git a/libs/gtkmm2/pango/pangomm/layout.h b/libs/gtkmm2/pango/pangomm/layout.h
index 6c836c73d6..dceee8c358 100644
--- a/libs/gtkmm2/pango/pangomm/layout.h
+++ b/libs/gtkmm2/pango/pangomm/layout.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_LAYOUT_H
 #define _PANGOMM_LAYOUT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -209,32 +208,6 @@ public:
   static Glib::RefPtr<Layout> create(const Glib::RefPtr<Context>& context);
 
 
- /** Creates a layout object set up to match the current transformation
-  * and target surface of the Cairo context.  This layout can then be
-  * used for text measurement with functions like
-  * get_size() or drawing with methods like show_in_cairo_contet(). 
-  * If you change the transformation or target surface for @a context, 
-  * you need to call update_from_cairo_context()
-  *
-  * This is the most convenient way to use Cairo with Pango. 
-  * However it is slightly inefficient since it creates a separate
-  * Pango Context object for each layout. This might matter in an
-  * application that is laying out large amounts of text.
-  * 
-  * @param context A Cairo context.
-  * @result The newly created Pango Layout.
-  */
-  static Glib::RefPtr<Layout> create(const Cairo::RefPtr<Cairo::Context>& context);
-
-  /** Updates the private Pango Context of a Pango Layout created with
-   * create(const Cairo::RefPtr<Cairo::Context>&) to match the current transformation
-   * and target surface of a Cairo Context.
-   *
-   * @param context A Cairo context.
-   */
-  void update_from_cairo_context(const Cairo::RefPtr<Cairo::Context>& context);
-
-
   /** Does a deep copy-by-value of the @a src  layout. The attribute list,
    * tab array, and text from the original layout are all copied by
    * value.
@@ -302,15 +275,6 @@ public:
   void unset_font_description();
 
   
-  /** Gets the font description for the layout, if any.
-   * @return A pointer to the layout's font description,
-   * or <tt>0</tt> if the font description from the layout's
-   * context is inherited. This value is owned by the layout
-   * and must not be modified or freed.
-   */
-  FontDescription get_font_description() const;
-
-  
   /** Sets the width to which the lines of the Pango::Layout should be wrapped.
    * @param width The desired width, or -1 to indicate that no wrapping should be
    * performed.
@@ -492,20 +456,6 @@ public:
    * @return The position of the grapheme.
    */
   Rectangle index_to_pos(int index) const;
-  
-
-  /** Converts from byte @a index  within the @a layout  to line and X position.
-   * (X position is measured from the left edge of the line)
-   * @param index The byte index of a grapheme within the layout.
-   * @param trailing An integer indicating the edge of the grapheme to retrieve the 
-   * position of. If 0, the trailing edge of the grapheme, if &gt; 0, 
-   * the leading of the grapheme.
-   * @param line Location to store resulting line index. (which will
-   * between 0 and pango_layout_get_line_count(layout) - 1).
-   * @param x_pos Location to store resulting position within line
-   * (in thousandths of a device unit).
-   */
-  void index_to_line_x(int index_, bool trailing, int& line, int& x_pos) const;
 
   
   /** Given an index within a layout, determines the positions that of the
@@ -706,30 +656,15 @@ public:
   void get_iter(LayoutIter& iter);
 
 
-  /** Adds the text in this LayoutLine to the current path in the
-   * specified Cairo @a context. The origin of the glyphs (the left edge
-   * of the line) will be at the current point of the cairo context.
-   *
-   * @param context A Cairo context.
-   */
-  void add_to_cairo_context(const Cairo::RefPtr<Cairo::Context>& context);
-
-
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/layoutiter.cc b/libs/gtkmm2/pango/pangomm/layoutiter.cc
index 6e09fbc85f..4ba4620c3e 100644
--- a/libs/gtkmm2/pango/pangomm/layoutiter.cc
+++ b/libs/gtkmm2/pango/pangomm/layoutiter.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/layoutiter.h>
 #include <pangomm/private/layoutiter_p.h>
 
@@ -140,10 +139,10 @@ Glib::RefPtr<LayoutLine> LayoutIter::get_line() const
 {
 
   Glib::RefPtr<LayoutLine> retvalue = Glib::wrap(pango_layout_iter_get_line(const_cast<PangoLayoutIter*>(gobj())));
+
   if(retvalue)
     retvalue->reference(); //The function does not do a ref for us.
   return retvalue;
-
 }
 
 bool LayoutIter::at_last_line() const
@@ -173,27 +172,27 @@ bool LayoutIter::next_line()
 
 void LayoutIter::get_cluster_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_iter_get_cluster_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_iter_get_cluster_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 void LayoutIter::get_run_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_iter_get_run_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_iter_get_run_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 void LayoutIter::get_line_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_iter_get_line_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_iter_get_line_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 void LayoutIter::get_line_yrange(int& y0, int& y1) const
 {
-pango_layout_iter_get_line_yrange(const_cast<PangoLayoutIter*>(gobj()), &y0, &y1); 
+  pango_layout_iter_get_line_yrange(const_cast<PangoLayoutIter*>(gobj()), &y0, &y1);
 }
 
 void LayoutIter::get_layout_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_iter_get_layout_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_iter_get_layout_extents(const_cast<PangoLayoutIter*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 int LayoutIter::get_baseline() const
diff --git a/libs/gtkmm2/pango/pangomm/layoutiter.h b/libs/gtkmm2/pango/pangomm/layoutiter.h
index a76d73932e..ccb24ded81 100644
--- a/libs/gtkmm2/pango/pangomm/layoutiter.h
+++ b/libs/gtkmm2/pango/pangomm/layoutiter.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_LAYOUTITER_H
 #define _PANGOMM_LAYOUTITER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
diff --git a/libs/gtkmm2/pango/pangomm/layoutline.cc b/libs/gtkmm2/pango/pangomm/layoutline.cc
index f6e97b78a6..f3ff372461 100644
--- a/libs/gtkmm2/pango/pangomm/layoutline.cc
+++ b/libs/gtkmm2/pango/pangomm/layoutline.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/layoutline.h>
 #include <pangomm/private/layoutline_p.h>
 
@@ -27,7 +26,6 @@
  */
 
 #include <pangomm/layout.h>
-#include <pango/pangocairo.h>
 
 namespace Pango {
 
@@ -74,18 +72,9 @@ Glib::ArrayHandle<std::pair<int,int> > LayoutLine::get_x_ranges(int start_index,
   return Glib::ArrayHandle<std::pair<int,int> >(reinterpret_cast<std::pair<int,int>*>(ranges), n_ranges, Glib::OWNERSHIP_SHALLOW);
 }
 
-void LayoutLine::show_in_cairo_context(const Cairo::RefPtr<Cairo::Context>& context)
-{
-  pango_cairo_show_layout_line(context->cobj(), gobj());
-}
-
-void LayoutLine::add_to_cairo_context(const Cairo::RefPtr<Cairo::Context>& context)
-{
-  pango_cairo_layout_line_path(context->cobj(), gobj());
-}
-
 } /* namespace Pango */
 
+
 namespace
 {
 } // anonymous namespace
@@ -164,15 +153,15 @@ bool LayoutLine::x_to_index(int x_pos, int& index, int& trailing) const
 
 void LayoutLine::get_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_line_get_extents(const_cast<PangoLayoutLine*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_line_get_extents(const_cast<PangoLayoutLine*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
 void LayoutLine::get_pixel_extents(Rectangle& ink_rect, Rectangle& logical_rect) const
 {
-pango_layout_line_get_pixel_extents(const_cast<PangoLayoutLine*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj()); 
+  pango_layout_line_get_pixel_extents(const_cast<PangoLayoutLine*>(gobj()), (ink_rect).gobj(), (logical_rect).gobj());
 }
 
- Glib::RefPtr<Pango::Layout> LayoutLine::get_layout()
+Glib::RefPtr<Pango::Layout> LayoutLine::get_layout()
 {
   Glib::RefPtr<Pango::Layout> ref_ptr(Glib::wrap(gobj()->layout));
 
@@ -191,17 +180,17 @@ Glib::RefPtr<const Pango::Layout> LayoutLine::get_layout() const
 
   return ref_ptr;
 }
- 
- int LayoutLine::get_length() const
+
+int LayoutLine::get_length() const
 {
   return gobj()->length;
 }
- 
- int LayoutLine::get_start_index() const
+
+int LayoutLine::get_start_index() const
 {
   return gobj()->start_index;
 }
- 
+
 
 } // namespace Pango
 
diff --git a/libs/gtkmm2/pango/pangomm/layoutline.h b/libs/gtkmm2/pango/pangomm/layoutline.h
index 97ae47ba5b..594d5cc7a3 100644
--- a/libs/gtkmm2/pango/pangomm/layoutline.h
+++ b/libs/gtkmm2/pango/pangomm/layoutline.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_LAYOUTLINE_H
 #define _PANGOMM_LAYOUTLINE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -29,7 +28,6 @@
 
 #include <glibmm/slisthandle.h> // For the Glib::SListHandle typedef
 #include <pangomm/rectangle.h>
-#include <cairomm/context.h>
 #include <pango/pango-layout.h>
 
 
@@ -165,28 +163,12 @@ public:
    */
   Rectangle get_pixel_logical_extents() const;
 
-  /** Draws this LayoutLine in the specified Cairo context.
-   * The origin of the glyphs (the left edge of the line) will
-   * be drawn at the current point of the cairo context.
-   *
-   * @param context A Cairo context.
-   */
-  void show_in_cairo_context(const Cairo::RefPtr<Cairo::Context>& context);
-
-  /** Adds the text in this LayoutLine to the current path in the
-   * specified Cairo @a context. The origin of the glyphs (the left edge
-   * of the line) will be at the current point of the cairo context.
-   *
-   * @param context A Cairo context.
-   */
-  void add_to_cairo_context(const Cairo::RefPtr<Cairo::Context>& context);
-
-   Glib::RefPtr<Pango::Layout> get_layout();
+  Glib::RefPtr<Pango::Layout> get_layout();
   Glib::RefPtr<const Pango::Layout> get_layout() const;
-   //_MEMBER_SET_GOBJECT(layout, layout, Pango::Layout, PangoLayout*)
-   int get_length() const;
-    int get_start_index() const;
-     
+  //_MEMBER_SET_GOBJECT(layout, layout, Pango::Layout, PangoLayout*)
+  int get_length() const;
+  int get_start_index() const;
+    
 
 };
 
@@ -236,6 +218,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_LAYOUTLINE_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/layoutrun.cc b/libs/gtkmm2/pango/pangomm/layoutrun.cc
index f51982cad3..6d797fc02c 100644
--- a/libs/gtkmm2/pango/pangomm/layoutrun.cc
+++ b/libs/gtkmm2/pango/pangomm/layoutrun.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/layoutrun.h>
 #include <pangomm/private/layoutrun_p.h>
 
@@ -54,6 +53,7 @@ const Pango::LayoutRun& wrap(const PangoLayoutRun* object)
 
 } /* namespace Glib */
 
+
 namespace
 {
 } // anonymous namespace
@@ -63,16 +63,16 @@ namespace Pango
 {
 
 
- Item LayoutRun::get_item() const
+Item LayoutRun::get_item() const
 {
   return Item((gobj()->item));
 }
- 
- GlyphString LayoutRun::get_glyphs() const
+
+GlyphString LayoutRun::get_glyphs() const
 {
   return GlyphString((gobj()->glyphs));
 }
- 
+
 
 } // namespace Pango
 
diff --git a/libs/gtkmm2/pango/pangomm/layoutrun.h b/libs/gtkmm2/pango/pangomm/layoutrun.h
index 24170abc3e..8a150646fa 100644
--- a/libs/gtkmm2/pango/pangomm/layoutrun.h
+++ b/libs/gtkmm2/pango/pangomm/layoutrun.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_LAYOUTRUN_H
 #define _PANGOMM_LAYOUTRUN_H
 
-
 #include <glibmm.h>
 
 /* layoutrun.h
@@ -56,13 +55,13 @@ public:
   /** Gets the Pango::Item object that provides information about the segment of text in this run.
    * @return A Pango::Item object.
    */
-   Item get_item() const;
- 
+  Item get_item() const;
+
   /** Gets the string of glyphs obtained by shaping the text for this item.
    * @return A Pango::GlyphString object.
    */
-   GlyphString get_glyphs() const;
- 
+  GlyphString get_glyphs() const;
+
   /// Provides access to the underlying C GObject.  
   PangoLayoutRun*       gobj()       { return &gobject_; }
   /// Provides access to the underlying C GObject.
diff --git a/libs/gtkmm2/pango/pangomm/private/attributes_p.h b/libs/gtkmm2/pango/pangomm/private/attributes_p.h
index 522f33cf72..a2c62c09a6 100644
--- a/libs/gtkmm2/pango/pangomm/private/attributes_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/attributes_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_ATTRIBUTES_P_H
 #define _PANGOMM_ATTRIBUTES_P_H
-
-
 #endif /* _PANGOMM_ATTRIBUTES_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/attriter_p.h b/libs/gtkmm2/pango/pangomm/private/attriter_p.h
index 1fa847304f..d8cc2fd346 100644
--- a/libs/gtkmm2/pango/pangomm/private/attriter_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/attriter_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_ATTRITER_P_H
 #define _PANGOMM_ATTRITER_P_H
-
-
 #endif /* _PANGOMM_ATTRITER_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/attrlist_p.h b/libs/gtkmm2/pango/pangomm/private/attrlist_p.h
index 7a1188f8ef..4c05d959d2 100644
--- a/libs/gtkmm2/pango/pangomm/private/attrlist_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/attrlist_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_ATTRLIST_P_H
 #define _PANGOMM_ATTRLIST_P_H
-
-
 #endif /* _PANGOMM_ATTRLIST_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/cairofontmap_p.h b/libs/gtkmm2/pango/pangomm/private/cairofontmap_p.h
deleted file mode 100644
index 2bda5e63bd..0000000000
--- a/libs/gtkmm2/pango/pangomm/private/cairofontmap_p.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _PANGOMM_CAIROFONTMAP_P_H
-#define _PANGOMM_CAIROFONTMAP_P_H
-
-
-#include <glibmm/private/interface_p.h>
-
-#include <glibmm/private/interface_p.h>
-
-namespace Pango
-{
-
-class CairoFontMap_Class : public Glib::Interface_Class
-{
-public:
-  typedef CairoFontMap CppObjectType;
-  typedef PangoCairoFontMap BaseObjectType;
-  typedef PangoCairoFontMapIface BaseClassType;
-  typedef Glib::Interface_Class CppClassParent;
-
-  friend class CairoFontMap;
-
-  const Glib::Interface_Class& init();
-
-  static void iface_init_function(void* g_iface, void* iface_data);
-
-  static Glib::ObjectBase* wrap_new(GObject*);
-
-protected:
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-  //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-  //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
-
-
-} // namespace Pango
-
-
-#endif /* _PANGOMM_CAIROFONTMAP_P_H */
-
diff --git a/libs/gtkmm2/pango/pangomm/private/color_p.h b/libs/gtkmm2/pango/pangomm/private/color_p.h
index cfdaa5b917..945c38bedb 100644
--- a/libs/gtkmm2/pango/pangomm/private/color_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/color_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_COLOR_P_H
 #define _PANGOMM_COLOR_P_H
-
-
 #endif /* _PANGOMM_COLOR_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/context_p.h b/libs/gtkmm2/pango/pangomm/private/context_p.h
index be64b78f34..a54c181ffd 100644
--- a/libs/gtkmm2/pango/pangomm/private/context_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/context_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_CONTEXT_P_H
 #define _PANGOMM_CONTEXT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_CONTEXT_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/coverage_p.h b/libs/gtkmm2/pango/pangomm/private/coverage_p.h
index 3ae8dcbb84..129cefb95d 100644
--- a/libs/gtkmm2/pango/pangomm/private/coverage_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/coverage_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_COVERAGE_P_H
 #define _PANGOMM_COVERAGE_P_H
-
-
 #endif /* _PANGOMM_COVERAGE_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/font_p.h b/libs/gtkmm2/pango/pangomm/private/font_p.h
index b24bdb3808..6ff30d4ddf 100644
--- a/libs/gtkmm2/pango/pangomm/private/font_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/font_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_FONT_P_H
 #define _PANGOMM_FONT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_FONT_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/fontdescription_p.h b/libs/gtkmm2/pango/pangomm/private/fontdescription_p.h
index d68ba91e62..12ec7e662d 100644
--- a/libs/gtkmm2/pango/pangomm/private/fontdescription_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/fontdescription_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_FONTDESCRIPTION_P_H
 #define _PANGOMM_FONTDESCRIPTION_P_H
-
-
 #endif /* _PANGOMM_FONTDESCRIPTION_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/fontface_p.h b/libs/gtkmm2/pango/pangomm/private/fontface_p.h
index a7a114dac2..66bddd9298 100644
--- a/libs/gtkmm2/pango/pangomm/private/fontface_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/fontface_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_FONTFACE_P_H
 #define _PANGOMM_FONTFACE_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_FONTFACE_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/fontfamily_p.h b/libs/gtkmm2/pango/pangomm/private/fontfamily_p.h
index 7367d51273..657f7b266a 100644
--- a/libs/gtkmm2/pango/pangomm/private/fontfamily_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/fontfamily_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_FONTFAMILY_P_H
 #define _PANGOMM_FONTFAMILY_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_FONTFAMILY_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/fontmap_p.h b/libs/gtkmm2/pango/pangomm/private/fontmap_p.h
index 8aedc96332..88e898e016 100644
--- a/libs/gtkmm2/pango/pangomm/private/fontmap_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/fontmap_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_FONTMAP_P_H
 #define _PANGOMM_FONTMAP_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_FONTMAP_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/fontmetrics_p.h b/libs/gtkmm2/pango/pangomm/private/fontmetrics_p.h
index 5fa2c2110c..80670d0639 100644
--- a/libs/gtkmm2/pango/pangomm/private/fontmetrics_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/fontmetrics_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_FONTMETRICS_P_H
 #define _PANGOMM_FONTMETRICS_P_H
-
-
 #endif /* _PANGOMM_FONTMETRICS_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/fontset_p.h b/libs/gtkmm2/pango/pangomm/private/fontset_p.h
index e4461dd89d..ed012a1cbb 100644
--- a/libs/gtkmm2/pango/pangomm/private/fontset_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/fontset_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_FONTSET_P_H
 #define _PANGOMM_FONTSET_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_FONTSET_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/glyph_p.h b/libs/gtkmm2/pango/pangomm/private/glyph_p.h
index 06686a932b..8c4b42f6c7 100644
--- a/libs/gtkmm2/pango/pangomm/private/glyph_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/glyph_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_GLYPH_P_H
 #define _PANGOMM_GLYPH_P_H
-
-
 #endif /* _PANGOMM_GLYPH_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/glyphstring_p.h b/libs/gtkmm2/pango/pangomm/private/glyphstring_p.h
index a307fa2f37..6d9535bcda 100644
--- a/libs/gtkmm2/pango/pangomm/private/glyphstring_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/glyphstring_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_GLYPHSTRING_P_H
 #define _PANGOMM_GLYPHSTRING_P_H
-
-
 #endif /* _PANGOMM_GLYPHSTRING_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/item_p.h b/libs/gtkmm2/pango/pangomm/private/item_p.h
index 288ad5cded..a2015d337d 100644
--- a/libs/gtkmm2/pango/pangomm/private/item_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/item_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_ITEM_P_H
 #define _PANGOMM_ITEM_P_H
-
-
 #endif /* _PANGOMM_ITEM_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/language_p.h b/libs/gtkmm2/pango/pangomm/private/language_p.h
index 9445395c3c..f9921544be 100644
--- a/libs/gtkmm2/pango/pangomm/private/language_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/language_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_LANGUAGE_P_H
 #define _PANGOMM_LANGUAGE_P_H
-
-
 #endif /* _PANGOMM_LANGUAGE_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/layout_p.h b/libs/gtkmm2/pango/pangomm/private/layout_p.h
index 2e6a368425..d87fb6de2f 100644
--- a/libs/gtkmm2/pango/pangomm/private/layout_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/layout_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_LAYOUT_P_H
 #define _PANGOMM_LAYOUT_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_LAYOUT_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/layoutiter_p.h b/libs/gtkmm2/pango/pangomm/private/layoutiter_p.h
index fa0ec3f94b..e43c4334d2 100644
--- a/libs/gtkmm2/pango/pangomm/private/layoutiter_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/layoutiter_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_LAYOUTITER_P_H
 #define _PANGOMM_LAYOUTITER_P_H
-
-
 #endif /* _PANGOMM_LAYOUTITER_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/layoutline_p.h b/libs/gtkmm2/pango/pangomm/private/layoutline_p.h
index f7b0610744..2bccde57d1 100644
--- a/libs/gtkmm2/pango/pangomm/private/layoutline_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/layoutline_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_LAYOUTLINE_P_H
 #define _PANGOMM_LAYOUTLINE_P_H
-
-
 #endif /* _PANGOMM_LAYOUTLINE_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/layoutrun_p.h b/libs/gtkmm2/pango/pangomm/private/layoutrun_p.h
index 8e44d36a3f..3d9bb774f1 100644
--- a/libs/gtkmm2/pango/pangomm/private/layoutrun_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/layoutrun_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_LAYOUTRUN_P_H
 #define _PANGOMM_LAYOUTRUN_P_H
-
-
 #endif /* _PANGOMM_LAYOUTRUN_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/rectangle_p.h b/libs/gtkmm2/pango/pangomm/private/rectangle_p.h
index 18ee9f04f2..4b3e6f2481 100644
--- a/libs/gtkmm2/pango/pangomm/private/rectangle_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/rectangle_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_RECTANGLE_P_H
 #define _PANGOMM_RECTANGLE_P_H
-
-
 #endif /* _PANGOMM_RECTANGLE_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/renderer_p.h b/libs/gtkmm2/pango/pangomm/private/renderer_p.h
index 5909e8cfb0..1c24c86970 100644
--- a/libs/gtkmm2/pango/pangomm/private/renderer_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/renderer_p.h
@@ -2,8 +2,6 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_RENDERER_P_H
 #define _PANGOMM_RENDERER_P_H
-
-
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
@@ -32,20 +30,15 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
 } // namespace Pango
 
-
 #endif /* _PANGOMM_RENDERER_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/private/tabarray_p.h b/libs/gtkmm2/pango/pangomm/private/tabarray_p.h
index ca33babdd8..d27ae8534a 100644
--- a/libs/gtkmm2/pango/pangomm/private/tabarray_p.h
+++ b/libs/gtkmm2/pango/pangomm/private/tabarray_p.h
@@ -2,7 +2,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 #ifndef _PANGOMM_TABARRAY_P_H
 #define _PANGOMM_TABARRAY_P_H
-
-
 #endif /* _PANGOMM_TABARRAY_P_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/rectangle.cc b/libs/gtkmm2/pango/pangomm/rectangle.cc
index 9070af3cd2..4686d3a7d0 100644
--- a/libs/gtkmm2/pango/pangomm/rectangle.cc
+++ b/libs/gtkmm2/pango/pangomm/rectangle.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/rectangle.h>
 #include <pangomm/private/rectangle_p.h>
 
@@ -70,6 +69,7 @@ const Pango::Rectangle& wrap(const PangoRectangle* object)
 
 } /* namespace Glib */
 
+
 namespace
 {
 } // anonymous namespace
diff --git a/libs/gtkmm2/pango/pangomm/rectangle.h b/libs/gtkmm2/pango/pangomm/rectangle.h
index 9489d6d959..beb6825406 100644
--- a/libs/gtkmm2/pango/pangomm/rectangle.h
+++ b/libs/gtkmm2/pango/pangomm/rectangle.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_RECTANGLE_H
 #define _PANGOMM_RECTANGLE_H
 
-
 #include <glibmm.h>
 
 /* Copyright (C) 2002 The gtkmm Development Team
@@ -160,6 +159,5 @@ const Pango::Rectangle& wrap(const PangoRectangle* object);
 
 } /* namespace Glib */
 
-
 #endif /* _PANGOMM_RECTANGLE_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/renderer.cc b/libs/gtkmm2/pango/pangomm/renderer.cc
index 0c3ec48cf2..e456fc19cf 100644
--- a/libs/gtkmm2/pango/pangomm/renderer.cc
+++ b/libs/gtkmm2/pango/pangomm/renderer.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/renderer.h>
 #include <pangomm/private/renderer_p.h>
 
@@ -28,25 +27,13 @@
  */
 
 #include <pango/pango-renderer.h>
-#include <pango/pango-types.h> //For PANGO_MATRIX_INIT
 
 namespace Pango
 {
 
-Matrix Renderer::get_matrix() const
-{
-  const PangoMatrix* matrix = pango_renderer_get_matrix(const_cast<PangoRenderer*>(gobj()));
-  if(matrix)
-    return *matrix;
-  else
-  {
-    PangoMatrix identity_transform = PANGO_MATRIX_INIT;
-    return identity_transform;
-  }
-}
-
 } /* namespace Pango */
 
+
 namespace
 {
 } // anonymous namespace
@@ -101,19 +88,8 @@ void Renderer_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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
 
 Glib::ObjectBase* Renderer_Class::wrap_new(GObject* object)
 {
@@ -158,57 +134,57 @@ GType Renderer::get_base_type()
 
 void Renderer::draw_layout(const Glib::RefPtr<Layout>& layout, int x, int y)
 {
-pango_renderer_draw_layout(gobj(), Glib::unwrap(layout), x, y); 
+  pango_renderer_draw_layout(gobj(), Glib::unwrap(layout), x, y);
 }
 
 void Renderer::draw_layout_line(const Glib::RefPtr<LayoutLine>& line, int x, int y)
 {
-pango_renderer_draw_layout_line(gobj(), Glib::unwrap(line), x, y); 
+  pango_renderer_draw_layout_line(gobj(), Glib::unwrap(line), x, y);
 }
 
 void Renderer::draw_glyphs(const Glib::RefPtr<Font>& font, const GlyphString& glyphs, int x, int y)
 {
-pango_renderer_draw_glyphs(gobj(), Glib::unwrap(font), const_cast<PangoGlyphString*>(glyphs.gobj()), x, y); 
+  pango_renderer_draw_glyphs(gobj(), Glib::unwrap(font), const_cast<PangoGlyphString*>(glyphs.gobj()), x, y);
 }
 
 void Renderer::draw_rectangle(RenderPart part, int x, int y, int width, int height)
 {
-pango_renderer_draw_rectangle(gobj(), ((PangoRenderPart)(part)), x, y, width, height); 
+  pango_renderer_draw_rectangle(gobj(), ((PangoRenderPart)(part)), x, y, width, height);
 }
 
 void Renderer::draw_error_underline(int x, int y, int width, int height)
 {
-pango_renderer_draw_error_underline(gobj(), x, y, width, height); 
+  pango_renderer_draw_error_underline(gobj(), x, y, width, height);
 }
 
 void Renderer::draw_trapezoid(RenderPart part, double y1, double x11, double x21, double y2, double x12, double x22)
 {
-pango_renderer_draw_trapezoid(gobj(), ((PangoRenderPart)(part)), y1, x11, x21, y2, x12, x22); 
+  pango_renderer_draw_trapezoid(gobj(), ((PangoRenderPart)(part)), y1, x11, x21, y2, x12, x22);
 }
 
 void Renderer::draw_glyph(const Glib::RefPtr<Font>& font, Glyph glyph, double x, double y)
 {
-pango_renderer_draw_glyph(gobj(), Glib::unwrap(font), glyph, x, y); 
+  pango_renderer_draw_glyph(gobj(), Glib::unwrap(font), glyph, x, y);
 }
 
 void Renderer::activate()
 {
-pango_renderer_activate(gobj()); 
+  pango_renderer_activate(gobj());
 }
 
 void Renderer::deactivate()
 {
-pango_renderer_deactivate(gobj()); 
+  pango_renderer_deactivate(gobj());
 }
 
 void Renderer::part_changed(RenderPart part)
 {
-pango_renderer_part_changed(gobj(), ((PangoRenderPart)(part))); 
+  pango_renderer_part_changed(gobj(), ((PangoRenderPart)(part)));
 }
 
 void Renderer::set_color(RenderPart part, const Color& color)
 {
-pango_renderer_set_color(gobj(), ((PangoRenderPart)(part)), (color).gobj()); 
+  pango_renderer_set_color(gobj(), ((PangoRenderPart)(part)), (color).gobj());
 }
 
 Color Renderer::get_color(RenderPart part) const
@@ -218,17 +194,10 @@ Color Renderer::get_color(RenderPart part) const
 
 void Renderer::set_matrix(const Matrix& matrix)
 {
-pango_renderer_set_matrix(gobj(), &(matrix)); 
+  pango_renderer_set_matrix(gobj(), &(matrix));
 }
 
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Pango
 
 
diff --git a/libs/gtkmm2/pango/pangomm/renderer.h b/libs/gtkmm2/pango/pangomm/renderer.h
index da16a59279..8428c15b50 100644
--- a/libs/gtkmm2/pango/pangomm/renderer.h
+++ b/libs/gtkmm2/pango/pangomm/renderer.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_RENDERER_H
 #define _PANGOMM_RENDERER_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -33,6 +32,7 @@
 #include <pangomm/glyphstring.h>
 #include <pangomm/layout.h>
 #include <pangomm/layoutline.h>
+#include <pangomm/types.h> //For Matrix.
 
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -287,24 +287,19 @@ public:
    * (No matrix set is the same as setting the identity matrix.).
    */
   void set_matrix(const Matrix& matrix);
-  Matrix get_matrix() const;
-  
+  //TOOD: _WRAP_METHOD(Matrix get_matrix(), pango_renderer_get_matrix)
+  //Note: The returned matrix is owned by Pango and must not be modified or freed.
+
 
 public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
 
 };
diff --git a/libs/gtkmm2/pango/pangomm/tabarray.cc b/libs/gtkmm2/pango/pangomm/tabarray.cc
index 2e750d49ea..57353f418a 100644
--- a/libs/gtkmm2/pango/pangomm/tabarray.cc
+++ b/libs/gtkmm2/pango/pangomm/tabarray.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <pangomm/tabarray.h>
 #include <pangomm/private/tabarray_p.h>
 
@@ -37,11 +36,9 @@ TabArray::TabArray(int initial_size, bool positions_in_pixels)
 
 std::pair<TabAlign,int> TabArray::get_tab(int tab_index) const
 {
-  PangoTabAlign p_alignment;
   TabAlign alignment;
   int location;
-  pango_tab_array_get_tab(const_cast<PangoTabArray*>(gobj()), tab_index, &p_alignment, &location);
-  alignment = static_cast<TabAlign>(p_alignment);
+  pango_tab_array_get_tab(const_cast<PangoTabArray*>(gobj()), tab_index, (PangoTabAlign*)&alignment, &location);
   return std::pair<TabAlign,int>(alignment, location);
 }
 
@@ -165,12 +162,12 @@ int TabArray::get_size() const
 
 void TabArray::resize(int new_size)
 {
-pango_tab_array_resize(gobj(), new_size); 
+  pango_tab_array_resize(gobj(), new_size);
 }
 
 void TabArray::set_tab(int tab_index, TabAlign alignment, int location)
 {
-pango_tab_array_set_tab(gobj(), tab_index, ((PangoTabAlign)(alignment)), location); 
+  pango_tab_array_set_tab(gobj(), tab_index, ((PangoTabAlign)(alignment)), location);
 }
 
 bool TabArray::get_positions_in_pixels() const
diff --git a/libs/gtkmm2/pango/pangomm/tabarray.h b/libs/gtkmm2/pango/pangomm/tabarray.h
index c8fc543933..7a5850c663 100644
--- a/libs/gtkmm2/pango/pangomm/tabarray.h
+++ b/libs/gtkmm2/pango/pangomm/tabarray.h
@@ -3,7 +3,6 @@
 #ifndef _PANGOMM_TABARRAY_H
 #define _PANGOMM_TABARRAY_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -192,6 +191,5 @@ class Value<Pango::TabArray> : public Glib::Value_Boxed<Pango::TabArray>
 
 } // namespace Glib
 
-
 #endif /* _PANGOMM_TABARRAY_H */
 
diff --git a/libs/gtkmm2/pango/pangomm/wrap_init.cc b/libs/gtkmm2/pango/pangomm/wrap_init.cc
index d383d05187..348d28fabd 100644
--- a/libs/gtkmm2/pango/pangomm/wrap_init.cc
+++ b/libs/gtkmm2/pango/pangomm/wrap_init.cc
@@ -15,7 +15,6 @@
 #include "attributes.h"
 #include "attriter.h"
 #include "attrlist.h"
-#include "cairofontmap.h"
 #include "color.h"
 #include "context.h"
 #include "coverage.h"
diff --git a/libs/gtkmm2ext/SConscript b/libs/gtkmm2ext/SConscript
index 286587e869..504801aa03 100644
--- a/libs/gtkmm2ext/SConscript
+++ b/libs/gtkmm2ext/SConscript
@@ -15,8 +15,7 @@ gtkmm2ext.Merge ([
     libraries['pangomm'],
     libraries['atkmm'],
     libraries['gdkmm2'],
-    libraries['gtkmm2'],
-    libraries['cairomm']
+    libraries['gtkmm2']
     ])
 
 #
@@ -28,9 +27,6 @@ domain = 'libgtkmm2ext'
 gtkmm2ext.Append(DOMAIN=domain,MAJOR=0,MINOR=8,MICRO=3)
 gtkmm2ext.Append(CXXFLAGS="-DPACKAGE=\\\"" + domain + "\\\"")
 gtkmm2ext.Append(CXXFLAGS="-DLIBSIGC_DISABLE_DEPRECATED")
-gtkmm2ext.Append(CXXFLAGS="-DGLIBMM_DISABLE_DEPRECATED")
-gtkmm2ext.Append(CXXFLAGS="-DGDKMM_DISABLE_DEPRECATED")
-gtkmm2ext.Append(CXXFLAGS="-DGTKMM_DISABLE_DEPRECATED")
 #gtkmm2ext.Append(CPPPATH='#libs/surfaces/control_protocol')
 gtkmm2ext.Append(PACKAGE=domain)
 gtkmm2ext.Append(POTFILE=domain + '.pot')
diff --git a/libs/gtkmm2ext/tearoff.cc b/libs/gtkmm2ext/tearoff.cc
index 3df70ad54b..92bde5541e 100644
--- a/libs/gtkmm2ext/tearoff.cc
+++ b/libs/gtkmm2ext/tearoff.cc
@@ -51,7 +51,7 @@ TearOff::TearOff (Widget& c, bool allow_resize)
 	
 	VBox* box1;
 	box1 = manage (new VBox);
-	box1->pack_start (close_event_box, false, false, 5);
+	box1->pack_start (close_event_box, false, false, 2);
 	
 	window_box.pack_end (*box1, false, false, 2);
 	own_window.add (window_box);
@@ -67,7 +67,7 @@ TearOff::TearOff (Widget& c, bool allow_resize)
 
 	VBox* box2;
 	box2 = manage (new VBox);
-	box2->pack_start (tearoff_event_box, false, false, 5);
+	box2->pack_start (tearoff_event_box, false, false, 2);
 
 	pack_start (contents);
 	pack_start (*box2, false, false, 2);
diff --git a/libs/libglademm/AUTHORS b/libs/libglademm/AUTHORS
new file mode 100644
index 0000000000..0258b21bfe
--- /dev/null
+++ b/libs/libglademm/AUTHORS
@@ -0,0 +1,2 @@
+Maintainers:
+Murray Cumming <murrayc@usa.net>
diff --git a/libs/cairomm/COPYING b/libs/libglademm/COPYING
index f5030495bf..b1e3f5a263 100644
--- a/libs/cairomm/COPYING
+++ b/libs/libglademm/COPYING
@@ -1,13 +1,14 @@
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
 
- Copyright (C) 1991 Free Software Foundation, Inc.
-    		    59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ 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 library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
+[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
 
@@ -16,97 +17,109 @@ 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 Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, 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 or use pieces of it
-in new free programs; and that you know you can do these things.
+  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
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
+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 a program 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
+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.
 
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
+  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.
 
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
+  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.
 
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
+  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, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
 
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		  GNU LESSER GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
+  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
@@ -255,7 +268,7 @@ 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.
 
-  6. As an exception to the Sections above, you may also compile or
+  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
@@ -282,23 +295,31 @@ of these things:
     Library will not necessarily be able to recompile the application
     to use the modified definitions.)
 
-    b) Accompany the work with a written offer, valid for at
+    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.
 
-    c) If distribution of the work is made by offering access to copy
+    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.
 
-    d) Verify that the user has already received a copy of these
+    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 source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
+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.
@@ -347,7 +368,7 @@ 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 to
+You are not responsible for enforcing compliance by third parties with
 this License.
 
   11. If, as a consequence of a court judgment or allegation of patent
@@ -390,7 +411,7 @@ 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 Library General Public License from time to time.
+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.
 
@@ -453,16 +474,16 @@ convey the exclusion of warranty; and each file should have at least the
     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 Library General Public
+    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.
+    version 2.1 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.
+    Lesser General Public License for more details.
 
-    You should have received a copy of the GNU Library General Public
+    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
 
@@ -479,3 +500,5 @@ necessary.  Here is a sample; alter the names:
   Ty Coon, President of Vice
 
 That's all there is to it!
+
+
diff --git a/libs/libglademm/ChangeLog b/libs/libglademm/ChangeLog
new file mode 100644
index 0000000000..90bd943ff9
--- /dev/null
+++ b/libs/libglademm/ChangeLog
@@ -0,0 +1,361 @@
+2.6.1:
+
+2005-09-07  Murray Cumming  <murrayc@murrayc.com>
+
+	* NEWS: Updated.
+	* configure.in: Increased version.
+
+2005-03-10  Cedric Gustin <cedric.gustin@swing.be>
+
+	* MSVC_Net2003/Makefile.am: Add blank.cpp to EXTRA_DIST.
+	* MSVC_Net2003/libglademm/libglademm.vcproj: Disable warning #4250.
+	* MSVC_Net2003/examples/*/*.vcproj: Change name of
+	PDB file to $(OutDir)/$(TargetName).pdb. Disable warning #4250.
+
+2.6.0:
+
+2005-01-24  Cedric Gustin <cedric.gustin@swing.be>
+
+	* MSVC_Net2003/libglademm/Makefile.am: Rewrote rule for local copy
+	of glibmmconfig.h (required for 'make distcheck').
+	* MSVC_Net2003/libglademm/libglademm.vcproj: Removed GLIBMM_BUILD
+	macro.
+	
+2.5.1:
+
+2005-01-11  Murray Cumming  <murrayc@murrayc.com>
+
+	* MSVC_Net2003/libglademm/Makefile.am: Add libglademmconfig.h to 
+	DISTCLEANFILES, to fix the distcheck.
+
+2004-12-13  Cedric Gustin <cedric.gustin@swing.be>
+
+	* configure.in : parse version tags at configure time (for
+	libglademm-2.4.rc). 
+	* MSVC_Net2003/libglademm/libglademm-2.4.rc.in : New resource file.
+	* MSVC_Net2003/libglademm/Makefile.am: Include libglademm-2.4.rc
+	in distribution. 
+	* MSVC_Net2003/libglademm/libglademm.vcproj: Added resource file.
+
+2004-12-08  Cedric Gustin  <cedric.gustin@swing.be>
+  
+	* MSVC_Net2003/: Initial release.
+	* configure.in: Added MSVC_Net2003 Makefiles.
+	* Makefile.am: Added MSVC_Net2003 subdir.
+
+2004-08-28  Alberto Paro  <alberto@paro.homeunix.org>
+
+	* libglade/xml.{ccg|hg}: Added connect_clicked() for easy connection of
+	buttons and menuitems signals to a signal handler.
+	* libglade/variablesmap.[ccg|hg]:  Glade::VariablesMap now handles
+	Entry, ComboTextEntry, SpinButton, *Scale, Calendar and CheckBox.
+	* example/variablesmap:  Improved the example to handle new
+	VariablesMap types.
+
+2004-09-19  Murray Cumming  <murrayc@murrayc.com>
+
+	* This is the HEAD branch.
+
+2004-09-19  Murray Cumming  <murrayc@murrayc.com>
+
+	* libglademm/xml.hg: Fix from Denis Leroy in bug #151872. 
+
+2.4.1:
+
+2004-06-02  Bryan Forbes  <bryan@reigndropsfall.net>
+
+	* examples/derived/deriveddialog.h: fix to compile with gcc 3.4.0.
+
+2.4.0:
+
+2.3.3:
+
+2004-03-28  <jdhall@uiuc.edu>
+ 
+ 	* libglade/xml.hg: Check the return value of get_cwidget(). 
+
+2004-03-18  Murray Cumming  <murrayc@murrayc.com>
+
+	* docs/reference/Makefile.am: Removed make target dependency on 
+	installed beautify_docs, so it does not try to rebuild them when
+	building from a tarball. Bug #137548 from Dalgoda.
+
+2004-03-15  Cedric Gustin  <cedric.gustin@swing.be>
+
+	* tools/m4/Makefile.am: install m4 files in libglademm-2.4 subdir
+	instead of libglademm-2.0.
+
+2004-03-15  Cedric Gustin  <cedric.gustin@swing.be>
+
+	* configure.in: Added test for struct packing convention on win32
+	(-mms-bitfields / -fnative-struct).
+
+2004-03-12  Murray Cumming  <murrayc@murrayc.com>
+
+	* libglade/src/xml.hg: get_widget_derived(): actually return the 
+	existing widget when a wrapper instance already exists. Bug #136913 
+	from Roger Whinlatter who submitted it to debian but should have 
+	submitted it to bugzilla.gnome.org first.
+	
+2.3.2:
+	
+2004-02-13  Murray Cumming  <murrayc@murrayc.com>
+
+	* Updated for latest libsigc++ 2 API.
+
+2.3.1:
+
+2003-12-31  Murray Cumming  <murrayc@usa.net>
+
+	* docs/reference/Makefile.am: Generate a real devhelp file. Added
+	a doxygen_to_devhelp.xsl file for this, by copying it from gtkmm and
+	modifying it.
+
+2003-12-29  Murray Cumming  <murrayc@usa.net>
+
+	* configure.in: Use glibmm_check_perl() m4 macro installed by glibmm,
+	so that doxygen can know the PERL_PATH.
+	* docs/reference/Makefile.am: Added the docs rules from the same
+	file in gtkmm, so that the docs are built and distributed and installed
+	and uploaded.
+
+2003-12-22  Murray Cumming  <murrayc@usa.net>
+
+	* docs/reference/Makefile.am: Use beautify_docs.pl installed from
+	glibmm 2.4.
+
+2.3.0:
+
+2003-12-07  Murray Cumming  <murrayc@usa.net>
+ 
+ 	* examples/menus/example.glade: Corrected the text. Patch by
+ 	Billy O'Connor in bug 128683.
+
+2003-11-29  Murray Cumming  <murrayc@usa.net>
+
+	* libglade/libglade-2.0.pc.in: Corrected library name.
+
+2003-11-06  Cedric Gustin  <cedric.gustin@swing.be>
+
+	* configure.in: Added test of win32 platform. Commented
+	out AM_DISABLE_SHARED (DLLs are shared libraries).
+	* build_shared/Makefile_build.am_fragment: added a few LDFLAGS 
+	for win32 DLLs (defined in win32_dlls_ldflags and appended to 
+	common_ldflags).
+
+2003-11-06  Murray Cumming  <murrayc@usa.net>
+
+	* Added examples/menus.
+	* examples/basic: Added and distributed basic.gladep which is 
+	necessary to prevent glade-2 from creating libgnomeui menus.
+
+2003-11-02  Murray Cumming  <murrayc@usa.net>
+
+	* This is now libglademm 2.4, which builds against gtkmm 2.4, and is 
+	parallel-installable with libglademm 2.0/2.2.
+
+This is HEAD, for GNOME 2.6, using gtkmm 2.4.
+	
+2003-10-30  Murray Cumming  <murrayc@usa.net>
+
+	* libglade/libglademm.h: Include gtkmmconfig.h rather than
+	libgnomemmconfig.h. These are platform-specific stuff. I am 
+	surprised that it built before, because this does not depend
+	on libgnomemm at all.
+
+2003-10-17  Alberto Paro  <alberto@paro.homeunix.org>
+
+	* docs/reference/Doxyfile.in: fixed docs generation 
+
+2.1.2:
+
+2003-09-25  Eric Bourque  <ericb@computer.org>
+
+ 	* libglademm.spec.in: new file
+
+2003-09-02  Murray Cumming  <murrayc@usa.net>
+
+	* libglademm/src/xml.hg: Added code to get_widget_derived(),
+	to return an existing C++ instance if one exists. This makes 
+	get_widget_derived() always return the same instance, like
+	get_widget() already does. I added some more explicit explanation
+	to the gtkmm book about this. 
+
+2.1.1:
+	
+2003-09-01  Murray Cumming  <murrayc@usa.net>
+
+	* Just rebuilt the tarball. Some corruption was causing the
+	.la files to not be installed.
+
+2.1.0:
+
+2003-08-23  Murray Cumming  <murrayc@usa.net>
+	
+	* libglademm/src/xml.[hg|ccg]: Added 
+	Glade::Xml::get_widget_derived() templated method.
+	* Added examples/derived/ to demonstrate it. This allows you
+	to encapsulate the handling of the child widgets inside the
+	container widget's code.
+	* Makefile.am: Added examples to SUBDIRS so that they are built
+	by default, for regression testing.
+	* examples/Makefile.am_fragment: Added top_srcdir include for
+	distcheck.
+
+2.0.0:
+
+2002-12-20  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* examples/basic/basic.cc (main): Exit the program if loading
+	the glade file failed, so that it won't segfault.
+
+2002-12-20  Murray Cumming  <murrayc@usa.net>
+
+	* _IGNORE()ed some internal libglade functions.
+
+2002-12-20  Murray Cumming  <murrayc@usa.net>
+
+	* examples/basic/basic.cc: Used try/catch to catch the new XmlError
+	exception. Added some comments.
+
+2002-12-20  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* libglade/src/xml.{ccg,hg} (XmlError): New exception class.
+	(Xml::Xml): Throw an XmlError exception if glade_xml_construct()
+	or glade_xml_create_from_buffer() failed.
+
+2002-12-16  Daniel Elstner  <daniel.elstner@gmx.net>
+
+	* libglade/src/xml.{ccg,hg} (Xml::Xml): In order to reduce code
+	size, replace the ctor overloads with a single ctor and default
+	arguments, and treat empty strings as 0.  Also, use std::string
+	instead of Glib::ustring for the filename argument.
+	(Xml::Xml): Add ctor overload for glade_xml_new_from_buffer().
+	We should use a construct() function instead but that requires
+	an API addition to libglade.
+	(Xml::create): Use std::string for the filename argument, and
+	reduce code by using default arguments instead of 3 overloads.
+	(Xml::create_from_buffer): Take a plain const char* for the buffer
+	argument, plus an int for its size.  We already need to do this
+	for the ctor to avoid overload ambiguities, and I don't see much
+	of a point in providing an additional create_from_buffer() overload
+	since it's rarely used.
+	(Xml::get_widget_checked): New internal method that checks the
+	type of the widget and prints a warning on failure.
+	(Xml::get_widget): Move most of the code into the non-templated
+	method get_widget_checked(), to reduce binary size.
+	(Xml::relative_file): Take and return std::string, since it's
+	a filename.
+	(Xml::get_filename): New accessor to public struct data member.
+	(Xml::get_widget_name): Add.
+	(Xml::glade_get_widget_tree): Add.
+
+	* tools/m4/convert_libglademm.m4: Add conversion from GladeXML*
+	to Glib::RefPtr<Xml>.
+
+2002-12-16  Murray Cumming  <murrayc@usa.net>
+
+	* src/xml.hg: reparent_widget() is no longer virtual.
+
+2002-12-16  Murray Cumming  <murrayc@usa.net>
+
+	* src/xml.[hg|ccg]: Renamed lookup_type() to lookup_type_vfunc(), to
+	be consistent with other gtkmm vfuncs, and made it virtual.
+
+2002-12-12  Murray Cumming  <murrayc@usa.net>
+
+	* configure.in: Increased version from 1.3.x to 2.0
+	* libglademm/libglademm/Makefile.am: Changed librarary name.
+	* libglademm/*.pc.in: Changed library name.
+	* examples/Makefile.am_fragment: Changed library name.
+
+2002-12-10  Bradley Bell  <btb@debian.org>
+
+	* scripts/Makefile.am: distribute macros.m4
+
+1.3.5:
+	* Updated for gtkmm2.
+	
+1.3.4:
+	
+2002-08-07  Murray Cumming  <murrayc@usa.net>
+
+	* Glade::Xml now uses the new gtkmm _CONSTRUCT macro, so it uses
+	the correct Glib::Object constructor.
+
+2002-08-06  Martin Schulze  <MHL.Schulze@t-online.de>
+
+	* examples/basic/Makefile.am: Replace 'example' with 'basic' to
+	match the actual file names.
+
+1.3.3:
+	
+2002-07-16  Murray Cumming  <murrayc@usa.net>
+
+	* Rebuilt for latest gtkmm.
+
+1.3.2:
+	
+2002-06-23  Murray Cumming  <murrayc@usa.net>
+
+	* Rebuilt for latest gtkmm.
+	* VariablesMap: Fixed "no return statement" warning.
+
+1.3.1:
+	
+2002-05-02  Murray Cumming  <murrayc@usa.net>
+
+	* Added Gnome::Glade::VariablesMap, with an example. This allows
+	you to map named Glade widgets to member variables, and transfer
+	all the data with one method call.
+
+1.3.0:
+	
+2002-04-29  Murray Cumming  <murrayc@usa.net>
+
+	* Added reparent_widget() method.
+
+2002-04-28  Murray Cumming  <murrayc@usa.net>
+
+	* Added templated get_widget(name, widget) override, which
+	does the dynamic casting and warns about any runtime errors, so
+	that application code doesn't need to.
+
+2002-04-25  Murray Cumming  <murrayc@usa.net>
+
+	* examples/basic: Use a GtkDialog in the .glade file instead of
+	the deprecated GnomeDialog. The signal connection now seems to
+	work.
+	* libglade/src/xml.[hg|ccg]: Added a lookup_type() vfunc
+	that instantiates gtkmm types instead of gtk+ types. This requires
+	the latest libglade.
+
+2002-04-25  Michael A. Koziarski  <michael@koziarski.org>
+
+	* libglade/src/xml.ccg
+	* libglade/src/xml.hg: As requested, implemented overloaded
+	create_from_buffer methods. 
+	
+2002-04-25  Murray Cumming  <murrayc@usa.net>
+
+	* Added "basic" example based on the libglade docs and Michael
+	Koziarski's .glade file.
+
+2002-04-24  Michael A. Koziarski  <michael@koziarski.org>
+
+	* libglade/src/xml.ccg
+	* libglade/src/xml.hg: Implemented overloaded create methods &
+	constructors.  Most applications won't need to send a domain
+	parameter, and some don't need a root parameter
+
+2002-04-23  Murray Cumming  <murrayc@usa.net>
+
+	* Generated sources are now distributed. The
+	build_shared/*.am_fragement files were copied from libgnomecanvasmm.
+
+2002-04-23  Murray Cumming  <murrayc@usa.net>
+
+	* Xml constructor uses the glade_xml_construct() function because
+	GladeXML doesn't have construct-time properties yet.
+	
+
diff --git a/libs/libglademm/NEWS b/libs/libglademm/NEWS
new file mode 100644
index 0000000000..52eacdedbe
--- /dev/null
+++ b/libs/libglademm/NEWS
@@ -0,0 +1,95 @@
+2.6.1:
+
+* Windows build fixes. (Cedric Gustin)
+
+2.6.0:
+
+libglademm 2.6 is API/ABI-compatible with libglademm 2.4.
+  
+Changes since libglademm 2.4:
+
+* Glade::Xml: Added connect_clicked() for easy connection of
+  buttons and menuitems signals. (Alberto Paro)
+* Glade::VariablesMap: now handles Entry, ComboTextEntry, 
+  SpinButton, *Scale, Calendar and CheckBox. (Alberto Paro).
+
+
+2.5.1:
+
+* Glade::Xml: Added connect_clicked() for easy connection of
+  buttons and menuitems signals. (Alberto Paro)
+* Glade::VariablesMap: now handles Entry, ComboTextEntry, 
+  SpinButton, *Scale, Calendar and CheckBox. (Alberto Paro).
+
+2.4.1:
+
+* gcc 3.4 build fix. (Bryan Forbes)
+
+2.4.0:
+
+The API is now stable.
+
+2.3.3:
+
+* get_widget():
+  - Don't create a C++ object with a null C object, when the 
+  C object can not be found. (jdhall)
+  - Really return existing widget wrappers. (Murray Cumming)
+* Stop accidental need for doxygen when building from tarballs.
+  (Murray Cumming)
+* win32: Test for -mms-bitfields / -fnative-struct.
+
+2.3.2:
+ 
+* Updated for new libsigc++ 2 syntax.
+
+2.3.1:
+
+Documentation:
+- Generate and install devhelp file.
+- beautify hmtl documentation, like the gtkmm docs.
+- Install html documentation.
+
+2.3.0:
+ 
+This is the new unstable branch of the parallel-installable libglademm 2.4,
+for use with gtkmm 2.4.
+
+2.1.2:
+
+* get_widget_derived() now returns an existing C++ instance if one exists, like
+  get_widget() already does. (Murray Cumming)
+
+2.1.1:
+
+No changes. Just recreated the tarball - it was not installing the .la files.
+
+2.1.0:
+
+This is the development phase for libglademm 2.2.0,
+which will add API but will not break API or ABI.
+
+* Added Glade::Xml::get_widget_derived() and 
+  examples/derived/ to demonstrate it.
+  This allows you to use Glade to layout your
+  own derived container widgets. Tell me what you
+  think.
+  (Murray Cumming)
+
+
+2.0.1:
+
+* Rebuilt the tarball with newer autotools, fixing the $SED problem.
+
+2.0.0
+
+* Glade::Xml::create() now throws an XmlError expection if it fails.
+  (Daniel Elstner)
+* Minimise use of templates, to reduce application code size.
+  (Daniel Elstner)
+
+1.3.5
+
+
+
+
diff --git a/libs/libglademm/SConscript b/libs/libglademm/SConscript
new file mode 100644
index 0000000000..0d22ba243f
--- /dev/null
+++ b/libs/libglademm/SConscript
@@ -0,0 +1,25 @@
+# -*- python -*-
+
+import os
+import os.path
+import glob
+
+Import('env libraries install_prefix')
+
+libglademm_files = glob.glob('libglademm/*.cc')
+
+libglademm = env.Copy()
+libglademm.Merge([libraries['gtk2'], libraries['glade2'], libraries['sigc2'], libraries['glibmm2'], libraries['pangomm'], libraries['atkmm'], libraries['gdkmm2'], libraries['gtkmm2']])
+
+libglade = libglademm.SharedLibrary('libglademm', libglademm_files)
+
+Default(libglade)
+
+env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2'), libglade))
+
+env.Alias('tarball', env.Distribute (env['DISTTREE'],
+                                     [ 'SConscript', 'libglademmconfig.h', 'libglademm.h'] +
+				     libglademm_files + 
+				     glob.glob('libglademm/*.h') +
+				     glob.glob('libglademm/private/*.h')
+				     ))
diff --git a/libs/libglademm/libglademm.h b/libs/libglademm/libglademm.h
new file mode 100644
index 0000000000..fb37dfb10d
--- /dev/null
+++ b/libs/libglademm/libglademm.h
@@ -0,0 +1,31 @@
+/* $Id$ */
+/* libglademm - a C++ wrapper for libglade
+ *
+ * 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 LIBGLADEMM_H
+#define LIBGLADEMM_H
+
+/* libglademm version.  */
+extern const int libglademm_major_version;
+extern const int libglademm_minor_version;
+extern const int libglademm_micro_version;
+
+#include <libglademm/xml.h>
+
+#endif /* #ifndef LIBGLADEMM_H */
diff --git a/libs/libglademm/libglademm/init.cc b/libs/libglademm/libglademm/init.cc
new file mode 100644
index 0000000000..5e394a8a40
--- /dev/null
+++ b/libs/libglademm/libglademm/init.cc
@@ -0,0 +1,34 @@
+// -*- c++ -*-
+/* $Id$ */
+
+/* init.cc
+ *
+ * Copyright 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.
+ */
+
+#include <libglademm/init.h>
+#include <libglademm/wrap_init.h>
+
+namespace Gnome
+{
+
+namespace Glade
+{
+
+
+} //namespace Glade
+} //namespace Gnome
diff --git a/libs/libglademm/libglademm/init.h b/libs/libglademm/libglademm/init.h
new file mode 100644
index 0000000000..8924769150
--- /dev/null
+++ b/libs/libglademm/libglademm/init.h
@@ -0,0 +1,38 @@
+// -*- c++ -*-
+#ifndef _LIBGLADEMM_INIT_H
+#define _LIBGLADEMM_INIT_H
+/* $Id$ */
+
+/* init.h
+ *
+ * Copyright 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.
+ */
+
+
+namespace Gnome
+{
+
+namespace Glade
+{
+
+
+
+} /* namespace Glade */
+} //namespace Gnome
+
+#endif //_LIBGLADEMM_INIT_H
+
diff --git a/libs/gtkmm2/gtk/gtkmm/private/pagesetup_p.h b/libs/libglademm/libglademm/private/xml_p.h
index beb8d38a46..e69f6798cc 100644
--- a/libs/gtkmm2/gtk/gtkmm/private/pagesetup_p.h
+++ b/libs/libglademm/libglademm/private/xml_p.h
@@ -1,27 +1,28 @@
 // -*- c++ -*-
 // Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _GTKMM_PAGESETUP_P_H
-#define _GTKMM_PAGESETUP_P_H
-
-
+#ifndef _LIBGLADEMM_XML_P_H
+#define _LIBGLADEMM_XML_P_H
 #include <glibmm/private/object_p.h>
 
 #include <glibmm/class.h>
 
-namespace Gtk
+namespace Gnome
+{
+
+namespace Glade
 {
 
-class PageSetup_Class : public Glib::Class
+class Xml_Class : public Glib::Class
 {
 public:
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
-  typedef PageSetup CppObjectType;
-  typedef GtkPageSetup BaseObjectType;
-  typedef GtkPageSetupClass BaseClassType;
+  typedef Xml CppObjectType;
+  typedef GladeXML BaseObjectType;
+  typedef GladeXMLClass BaseClassType;
   typedef Glib::Object_Class CppClassParent;
   typedef GObjectClass BaseClassParent;
 
-  friend class PageSetup;
+  friend class Xml;
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
   const Glib::Class& init();
@@ -32,20 +33,18 @@ public:
 
 protected:
 
-#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
   //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.
-#endif //GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-};
+  static GType lookup_type_vfunc_callback(GladeXML* self, const char* classname);
+  };
 
 
-} // namespace Gtk
+} // namespace Glade
 
+} // namespace Gnome
 
-#endif /* _GTKMM_PAGESETUP_P_H */
+#endif /* _LIBGLADEMM_XML_P_H */
 
diff --git a/libs/libglademm/libglademm/variablesmap.cc b/libs/libglademm/libglademm/variablesmap.cc
new file mode 100644
index 0000000000..57d9785bc3
--- /dev/null
+++ b/libs/libglademm/libglademm/variablesmap.cc
@@ -0,0 +1,199 @@
+/* variablesmap.cc
+ *
+ * Copyright (C) 2002 The libglademm 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 <libglademm/variablesmap.h>
+#include <gtkmm/togglebutton.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/calendar.h>
+#include <gtkmm/scale.h>
+#include <gtkmm/comboboxentry.h>
+
+namespace Gnome
+{
+
+namespace Glade
+{
+
+VariablesMap::VariablesMap(const Glib::RefPtr<Glade::Xml>& glade)
+: m_refGlade(glade)
+{
+}
+
+VariablesMap::~VariablesMap()
+{
+}
+
+
+void VariablesMap::connect_widget(const Glib::ustring& widget_name, bool& variable)
+{
+  Gtk::ToggleButton* pToggleButton = 0;
+  m_refGlade->get_widget(widget_name, pToggleButton); //Glade::Xml will complain if it is not a ToggleButton.
+  if(pToggleButton)
+  {
+    m_mapWidgetsToVariables[pToggleButton] = (void*)(&variable);
+  }
+}
+
+void VariablesMap::connect_widget(const Glib::ustring& widget_name, Glib::ustring& variable)
+{
+  Gtk::Widget* pWidget = 0;
+  m_refGlade->get_widget(widget_name, pWidget); 
+
+  Gtk::Entry* pEntry = dynamic_cast<Gtk::Entry*>(pWidget); //it mange both Gtk::entry and Gtk::SpinButton
+  Gtk::ComboBoxEntry* pComboBoxEntry = dynamic_cast<Gtk::ComboBoxEntry*>(pWidget);
+  if(pEntry)
+  {
+    m_mapWidgetsToVariables[pEntry] = (void*)(&variable);
+  }
+  if(pComboBoxEntry)
+  {
+    m_mapWidgetsToVariables[pComboBoxEntry] = (void*)(&variable);
+  }
+}
+
+void VariablesMap::connect_widget(const Glib::ustring& widget_name, double& variable)
+{
+  Gtk::Widget* pWidget = 0;
+  m_refGlade->get_widget(widget_name, pWidget); 
+
+  Gtk::Scale* pScale = dynamic_cast<Gtk::Scale*>(pWidget); 
+  if(pScale)
+  {
+    m_mapWidgetsToVariables[pScale] = (void*)(&variable);
+  }
+}
+
+void VariablesMap::connect_widget(const Glib::ustring& widget_name, Glib::Date& variable)
+{
+  Gtk::Widget* pWidget = 0;
+  m_refGlade->get_widget(widget_name, pWidget); 
+
+  Gtk::Calendar* pCalendar = dynamic_cast<Gtk::Calendar*>(pWidget); 
+  if(pCalendar)
+  {
+    m_mapWidgetsToVariables[pCalendar] = (void*)(&variable);
+  }
+}
+
+void VariablesMap::transfer_widgets_to_variables()
+{
+  if(validate_widgets()) //If the widgets' data is correct. Useful to override.
+  {
+    for(type_mapWidgetsToVariables::iterator iter =  m_mapWidgetsToVariables.begin(); iter != m_mapWidgetsToVariables.end(); ++iter)
+    {
+      transfer_one_widget(iter->first, true); //true = to_variable.
+    }
+  }
+}
+
+void VariablesMap::transfer_variables_to_widgets()
+{
+  for(type_mapWidgetsToVariables::iterator iter =  m_mapWidgetsToVariables.begin(); iter != m_mapWidgetsToVariables.end(); ++iter)
+  {
+    transfer_one_widget(iter->first, false); //false = to_widget.
+  }
+}
+
+
+void VariablesMap::transfer_one_widget(Gtk::Widget* pWidget, bool to_variable)
+{
+  //Find the widget in the map:
+  type_mapWidgetsToVariables::iterator iterFind = m_mapWidgetsToVariables.find(pWidget);
+  if(iterFind != m_mapWidgetsToVariables.end())
+  {
+    //Get the variable for the widget:
+    void* pVariable = iterFind->second;
+    if(pVariable)
+    {
+      //Cast the variable appropriately and set it appropriately:
+      Gtk::Entry* pEntry = dynamic_cast<Gtk::Entry*>(pWidget);
+      Gtk::ComboBoxEntry* pComboBoxEntry = dynamic_cast<Gtk::ComboBoxEntry*>(pWidget);
+
+      Gtk::ToggleButton* pToggleButton = dynamic_cast<Gtk::ToggleButton*>(pWidget); //CheckButtons and RadioButtons.
+      Gtk::Scale* pScale = dynamic_cast<Gtk::Scale*>(pWidget); 
+      Gtk::Calendar* pCalendar = dynamic_cast<Gtk::Calendar*>(pWidget); 
+
+      if(pEntry)
+      {
+        Glib::ustring* pVar = (Glib::ustring*)(pVariable);
+
+        if(to_variable)
+          (*pVar) = pEntry->get_text();
+        else
+          pEntry->set_text(*pVar);
+      }
+      if(pComboBoxEntry)
+      {
+        Glib::ustring* pVar = (Glib::ustring*)(pVariable);
+	Gtk::Entry* pIEntry = dynamic_cast<Gtk::Entry*>(pComboBoxEntry->get_child());
+
+        if(to_variable){
+	  if(pIEntry) 
+          	(*pVar) = pIEntry->get_text();
+        } else {
+	  if(pIEntry) 
+	          pIEntry->set_text(*pVar);
+	}
+      }
+      if(pToggleButton)
+      {
+        bool* pVar = (bool*)(pVariable);
+
+        if(to_variable)
+          (*pVar) = pToggleButton->get_active();
+        else
+          pToggleButton->set_active(*pVar);
+      }
+      if(pScale)
+      {
+        double* pVar = (double*)(pVariable);
+
+        if(to_variable)
+          (*pVar) = pScale->get_value();
+        else
+          pScale->set_value(*pVar);
+      }
+      if(pCalendar)
+      {
+        Glib::Date* pVar = (Glib::Date*)(pVariable);
+
+        if(to_variable){
+	   guint year,month,day;
+	   pCalendar->get_date(year,month,day);
+          (*pVar) = Glib::Date(day,(Glib::Date::Month)month,year);
+	} else {
+          pCalendar->select_day(pVar->get_day());
+          pCalendar->select_month(pVar->get_month(), pVar->get_year());
+	}
+      }
+    }
+  }
+}
+
+bool VariablesMap::validate_widgets()
+{
+  //Override to add validation.
+  //TODO: We could add some automatic data-range and text-length validation.
+  return true;
+}
+
+
+
+} /* namespace Glade */
+} /* namespace Gnome */
diff --git a/libs/libglademm/libglademm/variablesmap.h b/libs/libglademm/libglademm/variablesmap.h
new file mode 100644
index 0000000000..af8bbcdbb9
--- /dev/null
+++ b/libs/libglademm/libglademm/variablesmap.h
@@ -0,0 +1,96 @@
+/* variablesmap.h
+ *
+ * Copyright (C) 2002 The libglademm 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.
+ */
+
+#ifndef _LIBGLADEMM_VARIABLESMAP_H
+#define _LIBGLADEMM_VARIABLESMAP_H
+
+#include <libglademm/xml.h>
+#include <map>
+
+namespace Gnome
+{
+
+namespace Glade
+{
+
+/** Associates named Glade widgets with member variables.
+ * Use connect_widget() to link the widgets with variables that will contain their data.
+ * Then use transfer_widgets_to_variables() and transfer_variables_to_widgets() to get or set all of the variables at once.
+ *
+ * This is meant to be a bit like MFC's "Dialog Data Exchange and Validation".
+ *
+ * The association of widget and member varables follow this mapping:
+ *
+ * Gtk::Entry --> Glib::ustring
+ * Gtk::SpinBox --> Glib::ustring
+ * Gtk::ComboBoxEntry --> Glib::ustring
+ * Gtk::Scale --> double
+ * Gtk::Calendar --> Glib::Date
+ * Gtk::CheckBox --> bool
+ * Gtk::RadioButton --> bool
+ *
+ */
+class VariablesMap
+{
+public:
+  explicit VariablesMap(const Glib::RefPtr<Glade::Xml>& glade);
+  virtual ~VariablesMap();
+
+  ///For ToggleButton (CheckBox and RadioButton)
+  virtual void connect_widget(const Glib::ustring& widget_name, bool& variable);
+
+  ///For Entry, ComboBoxEntry and SpinBox
+  virtual void connect_widget(const Glib::ustring& widget_name, Glib::ustring& variable);
+
+  ///For Scale (HScale and VScale)
+  virtual void connect_widget(const Glib::ustring& widget_name, double& variable);
+
+  ///For Calendar
+  virtual void connect_widget(const Glib::ustring& widget_name, Glib::Date& variable);
+
+  ///Transfer data from the widget to the variable.
+  virtual void transfer_widgets_to_variables();
+
+  ///Transfer data from the variable to the widget.
+  virtual void transfer_variables_to_widgets();
+
+protected:
+
+  /** Override this to validate the data that the user enters into the widgets.
+   * The return value indicates whether the widgets' data is valid.
+   */
+  virtual bool validate_widgets();
+
+  virtual void transfer_one_widget(Gtk::Widget* pWidget, bool to_variable);
+
+  typedef std::map<Gtk::Widget*, void*> type_mapWidgetsToVariables;
+  type_mapWidgetsToVariables m_mapWidgetsToVariables;
+
+  Glib::RefPtr<Glade::Xml> m_refGlade;
+};
+
+} /* namespace Glade */
+} /* namespace Gnome */
+
+
+
+
+#endif /* _LIBGLADEMM_VARIABLESMAP_H */
+
+
diff --git a/libs/libglademm/libglademm/wrap_init.cc b/libs/libglademm/libglademm/wrap_init.cc
new file mode 100644
index 0000000000..ff78f96a4f
--- /dev/null
+++ b/libs/libglademm/libglademm/wrap_init.cc
@@ -0,0 +1,50 @@
+
+#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 <libglademm/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 "xml.h"
+
+extern "C"
+{
+
+//Declarations of the *_get_type() functions:
+
+GType glade_xml_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 Glade {  class Xml_Class { public: static Glib::ObjectBase* wrap_new(GObject*); };  } }
+
+namespace Gnome { namespace Glade { 
+
+void wrap_init()
+{
+  // Register Error domains:
+
+// Map gtypes to gtkmm wrapper-creation functions:
+  Glib::wrap_register(glade_xml_get_type(), &Gnome::Glade::Xml_Class::wrap_new);
+
+  // Register the gtkmm gtypes:
+  Gnome::Glade::Xml::get_type();
+
+} // wrap_init()
+
+} //Glade
+} //Gnome
+
+
diff --git a/libs/libglademm/libglademm/wrap_init.h b/libs/libglademm/libglademm/wrap_init.h
new file mode 100644
index 0000000000..59dcf4ae07
--- /dev/null
+++ b/libs/libglademm/libglademm/wrap_init.h
@@ -0,0 +1,37 @@
+#ifndef _LIBGLADEMM_WRAP_INIT_H
+#define _LIBGLADEMM_WRAP_INIT_H
+
+/* wrap_init.h
+ *
+ * Copyright (C) 1998-2001 The libglademm 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 UI
+{
+
+void wrap_init();
+
+} /* namespace UI */
+
+} /* namespace Gnome */
+
+#endif // _LIBGLADEMM_WRAP_INIT_H
diff --git a/libs/libglademm/libglademm/xml.cc b/libs/libglademm/libglademm/xml.cc
new file mode 100644
index 0000000000..5b672bc582
--- /dev/null
+++ b/libs/libglademm/libglademm/xml.cc
@@ -0,0 +1,343 @@
+// Generated by gtkmmproc -- DO NOT MODIFY!
+
+#include <libglademm/xml.h>
+#include <libglademm/private/xml_p.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The libglademm 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 <glade/glade-xml.h>
+#include <gtkmm/button.h>
+#include <gtkmm/menuitem.h>
+
+namespace Gnome
+{
+
+namespace Glade
+{
+
+XmlError::XmlError(const Glib::ustring& message)
+:
+  message_ (message)
+{}
+
+XmlError::~XmlError() throw()
+{}
+
+XmlError::XmlError(const XmlError& other)
+:
+  Glib::Exception (other),
+  message_        (other.message_)
+{}
+
+XmlError& XmlError::operator=(const XmlError& other)
+{
+  message_ = other.message_;
+  return *this;
+}
+
+Glib::ustring XmlError::what() const
+{
+  return message_;
+}
+
+
+Xml::Xml(const std::string& filename, const Glib::ustring& root, const Glib::ustring& domain)
+:
+  Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
+  Glib::Object(Glib::ConstructParams(xml_class_.init(), (char*) 0))
+{ 
+  if(!glade_xml_construct(gobj(), filename.c_str(), root.empty()   ? 0 : root.c_str(),
+                                                    domain.empty() ? 0 : domain.c_str()))
+  {
+    throw XmlError("Failed to load glade file `" + Glib::filename_to_utf8(filename) + '\'');
+  }
+}
+
+// TODO: we need glade_xml_construct_from_buffer()
+Xml::Xml(const char* buffer, int size, const Glib::ustring& root, const Glib::ustring& domain)
+:
+  Glib::ObjectBase(0),
+  Glib::Object((GObject*) glade_xml_new_from_buffer(
+      buffer, size, root.empty() ? 0 : root.c_str(), domain.empty() ? 0 : domain.c_str()))
+{
+  if(!gobj())
+    throw XmlError("Failed to read glade input buffer");
+}
+
+// static
+Glib::RefPtr<Xml> Xml::create(const std::string& filename,
+                              const Glib::ustring& root, const Glib::ustring& domain)
+{
+  return Glib::RefPtr<Xml>(new Xml(filename, root, domain));
+}
+
+// static
+Glib::RefPtr<Xml> Xml::create_from_buffer(const char* buffer, int size,
+                                          const Glib::ustring& root, const Glib::ustring& domain)
+{
+  return Glib::RefPtr<Xml>(new Xml(buffer, size, root, domain));
+}
+
+void Xml::reparent_widget(const Glib::ustring& name, Gtk::Container& container)
+{
+  Gtk::Widget* pWidget = 0;
+  get_widget(name, pWidget);
+
+  g_return_if_fail(pWidget != 0);
+
+  pWidget->reparent(container);
+}
+
+Gtk::Widget* Xml::get_widget_checked(const Glib::ustring& name, GType type)
+{
+  // Get the widget from the glade file.
+  Gtk::Widget *const pWidget = get_widget(name);
+
+  if(!pWidget)
+  {
+    g_critical("widget `%s' not found in glade file `%s'", name.c_str(), gobj()->filename);
+    return 0;
+  }
+
+  // Check if it has the correct type.
+  if(!g_type_is_a(G_OBJECT_TYPE(pWidget->gobj()), type))
+  {
+    g_critical("widget `%s' (in glade file `%s') is of type `%s' but `%s' was expected",
+               name.c_str(), gobj()->filename, G_OBJECT_TYPE_NAME(pWidget->gobj()), g_type_name(type));
+    return 0;
+  }
+
+  return pWidget;
+}
+
+GtkWidget* Xml::get_cwidget(const Glib::ustring& name)
+{
+  GtkWidget* pCWidget = glade_xml_get_widget(gobj(), name.c_str());
+  if(!pCWidget)
+    g_critical("Glade::Xml::get_cwidget(): glade_xml_get_widget() failed.");
+  
+  return pCWidget;
+}
+
+// Custom coded so that we can custom-code the vfunc in the Xml class.
+// This is marginally better than modifying gtkmmproc to allow this.
+//
+GType Xml_Class::lookup_type_vfunc_callback(GladeXML* self, const char* classname)
+{
+  CppObjectType *const obj = dynamic_cast<CppObjectType*>(
+      Glib::ObjectBase::_get_current_wrapper((GObject*) self));
+
+  if(obj)
+  {
+    try
+    {
+      return obj->lookup_type_vfunc(Glib::convert_const_gchar_ptr_to_ustring(classname));
+    }
+    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.
+    );
+
+    if(base && base->lookup_type)
+      return (*base->lookup_type)(self, classname);
+  }
+
+  return 0;
+}
+
+GType Xml::lookup_type_vfunc(const Glib::ustring& classname)
+{
+  // See if there is a gtkmm version of the gclass:
+  Glib::ustring classname_prefixed ("gtkmm__"); // gtkmm uses a prefix
+  classname_prefixed += classname;
+
+  GType gtype = g_type_from_name(classname_prefixed.c_str());
+
+  if(gtype == G_TYPE_INVALID) // if it's not a registered typename
+  {
+    // There's no gtkmm derived type, so just use the normal one.
+    gtype = g_type_from_name(classname.c_str());
+  }
+
+  return gtype;
+}
+
+void Xml::connect_clicked(const Glib::ustring& widget_name, const sigc::slot<void>& slot_ )
+{
+  Gtk::Widget* pWidget = 0;
+  get_widget(widget_name, pWidget);
+
+  Gtk::Button* pButton = dynamic_cast<Gtk::Button*>(pWidget);
+  Gtk::MenuItem* pMenuItem = dynamic_cast<Gtk::MenuItem*>(pWidget);
+
+  if(pButton)
+    pButton->signal_clicked().connect( slot_);
+
+  if(pMenuItem)
+    pMenuItem->signal_activate().connect( slot_ );
+}
+
+} // namespace Glade
+} // namespace Gnome
+
+
+namespace
+{
+} // anonymous namespace
+
+
+namespace Glib
+{
+
+Glib::RefPtr<Gnome::Glade::Xml> wrap(GladeXML* object, bool take_copy)
+{
+  return Glib::RefPtr<Gnome::Glade::Xml>( dynamic_cast<Gnome::Glade::Xml*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
+  //We use dynamic_cast<> in case of multiple inheritance.
+}
+
+} /* namespace Glib */
+
+
+namespace Gnome
+{
+
+namespace Glade
+{
+
+
+/* The *_Class implementation: */
+
+const Glib::Class& Xml_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_ = &Xml_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(glade_xml_get_type());
+
+    // Add derived versions of interfaces, if the C type implements any interfaces:
+  }
+
+  return *this;
+}
+
+void Xml_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->lookup_type = &lookup_type_vfunc_callback;
+  }
+
+
+Glib::ObjectBase* Xml_Class::wrap_new(GObject* object)
+{
+  return new Xml((GladeXML*)object);
+}
+
+
+/* The implementation: */
+
+GladeXML* Xml::gobj_copy()
+{
+  reference();
+  return gobj();
+}
+
+Xml::Xml(const Glib::ConstructParams& construct_params)
+:
+  Glib::Object(construct_params)
+{}
+
+Xml::Xml(GladeXML* castitem)
+:
+  Glib::Object((GObject*)(castitem))
+{}
+
+Xml::~Xml()
+{}
+
+
+Xml::CppClassType Xml::xml_class_; // initialize static member
+
+GType Xml::get_type()
+{
+  return xml_class_.init().get_type();
+}
+
+GType Xml::get_base_type()
+{
+  return glade_xml_get_type();
+}
+
+
+std::string Xml::get_filename() const
+{
+  return Glib::convert_const_gchar_ptr_to_stdstring(gobj()->filename);
+}
+
+Gtk::Widget* Xml::get_widget(const Glib::ustring& name)
+{
+  return Glib::wrap(glade_xml_get_widget(gobj(), name.c_str()));
+}
+
+Glib::ListHandle<Gtk::Widget*> Xml::get_widget_prefix(const Glib::ustring& name)
+{
+  return Glib::ListHandle<Gtk::Widget*>(glade_xml_get_widget_prefix(gobj(), name.c_str()), Glib::OWNERSHIP_SHALLOW);
+}
+
+std::string Xml::relative_file(const std::string& filename) const
+{
+  return Glib::convert_return_gchar_ptr_to_stdstring(glade_xml_relative_file(const_cast<GladeXML*>(gobj()), filename.c_str()));
+}
+
+Glib::ustring Xml::get_widget_name(Gtk::Widget& widget)
+{
+  return Glib::convert_const_gchar_ptr_to_ustring(glade_get_widget_name((widget).gobj()));
+}
+
+Glib::RefPtr<Xml> Xml::get_widget_tree(Gtk::Widget& widget)
+{
+
+  Glib::RefPtr<Xml> retvalue = Glib::wrap(glade_get_widget_tree((widget).gobj()));
+
+  if(retvalue)
+    retvalue->reference(); //The function does not do a ref for us.
+  return retvalue;
+}
+
+
+} // namespace Glade
+
+} // namespace Gnome
+
+
diff --git a/libs/libglademm/libglademm/xml.h b/libs/libglademm/libglademm/xml.h
new file mode 100644
index 0000000000..b0e5c440f7
--- /dev/null
+++ b/libs/libglademm/libglademm/xml.h
@@ -0,0 +1,348 @@
+// -*- c++ -*-
+// Generated by gtkmmproc -- DO NOT MODIFY!
+#ifndef _LIBGLADEMM_XML_H
+#define _LIBGLADEMM_XML_H
+
+#include <glibmm.h>
+
+/* $Id$ */
+
+/* Copyright (C) 2002 The libglademm 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/container.h>
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+typedef struct _GladeXML GladeXML;
+typedef struct _GladeXMLClass GladeXMLClass;
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+namespace Gnome
+{
+
+namespace Glade
+{ class Xml_Class; } // namespace Glade
+
+} // namespace Gnome
+namespace Gnome
+{
+
+namespace Glade
+{
+
+class XmlError : public Glib::Exception
+{
+public:
+  explicit XmlError(const Glib::ustring& message);
+  virtual ~XmlError() throw();
+
+  XmlError(const XmlError& other);
+  XmlError& operator=(const XmlError& other);
+
+  virtual Glib::ustring what() const;
+
+private:
+  Glib::ustring message_;
+};
+
+
+class Xml : public Glib::Object
+{
+  
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+public:
+  typedef Xml CppObjectType;
+  typedef Xml_Class CppClassType;
+  typedef GladeXML BaseObjectType;
+  typedef GladeXMLClass BaseClassType;
+
+private:  friend class Xml_Class;
+  static CppClassType xml_class_;
+
+private:
+  // noncopyable
+  Xml(const Xml&);
+  Xml& operator=(const Xml&);
+
+protected:
+  explicit Xml(const Glib::ConstructParams& construct_params);
+  explicit Xml(GladeXML* castitem);
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+public:
+  virtual ~Xml();
+
+#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 GObject.
+  GladeXML*       gobj()       { return reinterpret_cast<GladeXML*>(gobject_); }
+
+  ///Provides access to the underlying C GObject.
+  const GladeXML* gobj() const { return reinterpret_cast<GladeXML*>(gobject_); }
+
+  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
+  GladeXML* gobj_copy();
+
+private:
+
+  
+   //Ignore private glade_xml functions.
+
+protected:
+  /** Loads a glade XML file.
+   * @throw XmlError
+   */
+  Xml(const std::string& filename, const Glib::ustring& root, const Glib::ustring& domain);
+
+  /** Reads glade XML data from memory.
+   * @throw XmlError
+   */
+  Xml(const char* buffer, int size, const Glib::ustring& root, const Glib::ustring& domain);
+
+  Gtk::Widget* get_widget_checked(const Glib::ustring& name, GType type);
+  GtkWidget* get_cwidget(const Glib::ustring& name);
+
+public:
+  typedef Gnome::Glade::XmlError Error;
+
+  /** Loads a glade XML file.
+   * @throw XmlError
+   */
+  static Glib::RefPtr<Xml> create(const std::string& filename,
+                                  const Glib::ustring& root   = Glib::ustring(),
+                                  const Glib::ustring& domain = Glib::ustring());
+
+  /** Reads glade XML data from memory.
+   * @throw XmlError
+   */
+  static Glib::RefPtr<Xml> create_from_buffer(const char* buffer, int size,
+                                              const Glib::ustring& root   = Glib::ustring(),
+                                              const Glib::ustring& domain = Glib::ustring());
+
+  std::string get_filename() const;
+
+//void       glade_xml_signal_connect      (GladeXML *self,
+//					  const char *handlername,
+//					  GCallback func);
+//void       glade_xml_signal_connect_data (GladeXML *self,
+//					  const char *handlername,
+//					  GCallback func,
+//					  gpointer user_data);
+//
+//void       glade_xml_signal_autoconnect  (GladeXML *self);
+//
+//
+//typedef void (*GladeXMLConnectFunc) (const gchar *handler_name,
+//				     GObject *object,
+//				     const gchar *signal_name,
+//				     const gchar *signal_data,
+//				     GObject *connect_object,
+//				     gboolean after,
+//				     gpointer user_data);
+//
+//
+//void       glade_xml_signal_connect_full     (GladeXML *self,
+//					      const gchar *handler_name,
+//					      GladeXMLConnectFunc func,
+//					      gpointer user_data);
+//
+//void       glade_xml_signal_autoconnect_full (GladeXML *self,
+//					      GladeXMLConnectFunc func,
+//					      gpointer user_data);
+//
+//
+  /** Get a widget from the glade file.
+   * For instance:
+   * @code
+   * Gtk::Table* pTable = dynamic_cast<Gtk::Table*>(refXml->get_widget("mytable"));
+   * @endcode
+   * @param name The name of the widget.
+   * @return A pointer to the widget, or <tt>0</tt> on failure.
+   */
+  
+  Gtk::Widget* get_widget(const Glib::ustring& name);
+
+  /** This is for convenience.
+   * It allows for a shorter syntax with less repetition. For instance:
+   * @code
+   * Gtk::Table* pTable = 0;
+   * refXml->get_widget("mytable", pTable);
+   * @endcode
+   * This method prints a warning message to the console if the widget
+   * doesn't exist or has the wrong type, so you don't need to check that
+   * manually.
+   * @param name The name of the widget.
+   * @retval widget A pointer to the widget, or <tt>0</tt> on failure.
+   * @return The value of @a widget.
+   */
+  template <class T_Widget> inline
+  T_Widget* get_widget(const Glib::ustring& name, T_Widget*& widget)
+  {
+    // The dynamic_cast<> should never fail if get_widget_checked() succeeded.
+    widget = dynamic_cast<T_Widget*>(this->get_widget_checked(name, T_Widget::get_base_type()));
+
+    if(!widget)
+      g_critical("Gnome::Glade::Xml::get_widget(): dynamic_cast<> failed.");
+      
+    return widget;
+  }
+
+  /** This provides a pointer to a widget whose details are specified in the Glade file, but which is implemented
+   * by your own derived class. Your class must have a constructor like so:
+   * @code
+   * DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gnome::Glade::Xml>& refGlade)
+   * : Gtk::Dialog(cobject) //Calls the base class constructor
+   * @endcode
+   *
+   * For instance:
+   * @code
+   * Gtk::DerivedBox* pBox = 0;
+   * refXml->get_widget_derived("mybox", pBox);
+   * @endcode
+   *
+   * @param name The name of the widget.
+   * @retval widget A pointer to the widget, or <tt>0</tt> on failure.
+   * @return The value of @a widget.
+   */
+  template <class T_Widget> inline
+  T_Widget* get_widget_derived(const Glib::ustring& name, T_Widget*& widget)
+  {
+     // initialize input parameter
+     widget = 0;
+     
+     // Get the widget from the glade file.
+     typedef  typename T_Widget::BaseObjectType cwidget_type;
+     cwidget_type* pCWidget = (cwidget_type*)get_cwidget(name);
+
+     //The error was already reported by get_cwidget().
+     if(!pCWidget)
+       return 0;
+
+     //Check whether there is already a C++ wrapper instance associated with this C instance:
+     Glib::ObjectBase* pObjectBase = ObjectBase::_get_current_wrapper((GObject*)pCWidget);
+
+     //If there is already a C++ instance, then return it again:
+     if(pObjectBase)
+     {
+       widget = dynamic_cast<T_Widget*>( Glib::wrap((GtkWidget*)pCWidget) );
+       //Newer, more spec-complaint, versions of g++ not resolve a specific wrap() function in a template.
+
+       //The dynamic cast checks that it is of the correct type.
+       //Somebody might be trying to call get_widget_derived() after already calling get_widget(),
+       //or after already calling get_widget_derived() with a different derived C++ type.
+       if(!widget)
+        g_critical("Gnome::Glade::Xml::get_widget_derived(): dynamic_cast<> failed. An existing C++ instance, of a different type, seems to exist.");      
+     }
+     else
+     {
+       //Create a new C++ instance to wrap the existing C instance:
+       
+       //Set the output variable. We needed to do this because we can not template the return type.
+       Glib::RefPtr<Gnome::Glade::Xml> refThis(this);
+       refThis->reference(); //take a copy.
+       widget = new T_Widget(pCWidget, refThis);
+     }
+
+     //We return it as well (we need the parameter as well, because C++ can not just template the return type.)
+     return widget;
+  }
+
+  
+  Glib::ListHandle<Gtk::Widget*> get_widget_prefix(const Glib::ustring& name);
+
+  ///Take the widget from the glade-generated container and put it in another container.
+  void reparent_widget(const Glib::ustring& name, Gtk::Container& container);
+
+  
+  std::string relative_file(const std::string& filename) const;
+
+  
+  static Glib::ustring get_widget_name(Gtk::Widget& widget);
+  
+  static Glib::RefPtr<Xml> get_widget_tree(Gtk::Widget& widget);
+
+              
+  /** Connect a Gtk::Button's clicked signal or a Gtk::MenuItem's activated signal to a slot.
+   *
+   * For instance:
+   * @code
+   * refXml->connect_button("button", sigc::mem_fun(*this, &ExampleWindow::on_button_clicked) );
+   * @endcode
+   *
+   * @param name The name of the widget.
+   * @param pslot The slot to connect to.
+   */
+  void connect_clicked(const Glib::ustring& name, const sigc::slot<void>& slot_);
+
+
+///* interface for changing the custom widget handling */
+//typedef GtkWidget *(* GladeXMLCustomWidgetHandler) (GladeXML *xml,
+//						    gchar *func_name,
+//						    gchar *name,
+//						    gchar *string1,
+//						    gchar *string2,
+//						    gint int1,
+//						    gint int2,
+//						    gpointer user_data);
+
+//void glade_set_custom_handler(GladeXMLCustomWidgetHandler handler,
+//			      gpointer user_data);
+
+
+protected:
+
+  
+  virtual GType lookup_type_vfunc(const Glib::ustring& classname);
+
+
+public:
+
+public:
+  //C++ methods used to invoke GTK+ virtual functions:
+
+protected:
+  //GTK+ Virtual Functions (override these to change behaviour):
+
+  //Default Signal Handlers::
+
+
+};
+
+} // namespace Glade
+} // namespace Gnome
+
+
+namespace Glib
+{
+  /** @relates Gnome::Glade::Xml
+   * @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::Glade::Xml> wrap(GladeXML* object, bool take_copy = false);
+}
+
+
+#endif /* _LIBGLADEMM_XML_H */
+
diff --git a/libs/libglademm/libglademmconfig.h b/libs/libglademm/libglademmconfig.h
new file mode 100644
index 0000000000..9285bfc4f3
--- /dev/null
+++ b/libs/libglademm/libglademmconfig.h
@@ -0,0 +1,15 @@
+/* libglade/libglademmconfig.h.  Generated by configure.  */
+#ifndef _LIBGLADEMM_CONFIG_H
+#define _LIBGLADEMM_CONFIG_H 1
+
+#include "gtkmmconfig.h"
+
+/* version numbers */
+#define LIBGLADEMM_MAJOR_VERSION 2
+#define LIBGLADEMM_MINOR_VERSION 6
+#define LIBGLADEMM_MICRO_VERSION 1
+#define LIBGLADEMM_VERSION "2.6.1"
+#define LIBGLADE_VERSION_NEEDED_QUOTED "2.3.6"
+
+#endif /* _LIBGLADEMM_CONFIG_H */
+
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/.cvsignore b/libs/libgnomecanvasmm/.cvsignore
new file mode 100644
index 0000000000..e5d046710f
--- /dev/null
+++ b/libs/libgnomecanvasmm/.cvsignore
@@ -0,0 +1 @@
+*.dylib
diff --git a/libs/libgnomecanvasmm/ChangeLog b/libs/libgnomecanvasmm/ChangeLog
index 0adbf043eb..5de1d36668 100644
--- a/libs/libgnomecanvasmm/ChangeLog
+++ b/libs/libgnomecanvasmm/ChangeLog
@@ -1,58 +1,3 @@
-2.16.0:
-
-2.14.0:
-
-2005-12-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* libgnomecanvas/src/bpath.ccg:
-	* libgnomecanvas/src/bpath.hg: path property: 
-	Use GnomeCanvasDef* instead of RefPtr, because that 
-	breaks the API less, compared to the previous gpointer.
-
-2005-12-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* libgnomecanvas/src/bpath.hg: The path property is 
-	a PathDef, not a gpointer*. This theoretically breaks 
-	API/ABI, but it is useless if we do not change it, 
-	because the type is now checked in the C library.
-	* libgnomecanvas/src/libgnomecanvas_signals.defs: 
-	Update with h2defs.py, but ignoring API-break-causing 
-	writable/not-writable changes.
-	Bug #320502 by Pau Fernandez.
-
-2005-12-06   Jonathon Jongsma <jonathon.jongsma@gmail.com>
-
-	* configure.in: Look for gmmproc in generic libdir 
-	directory, because that is not always lib/. This 
-	fixes the build on some 64-bit systems.
-
-2.12.0:
-
-2005-09-07  Murray Cumming  <murrayc@murrayc.com
-
-	* Updated NEWS and increased version.
-2.11.1:
-
-2005-06-09  Murray Cumming  <murrayc@murrayc.com
-
-	* libgnomecanvas/src/item.ccg:
-	* libgnomecanvas/src/item.hg: Added get_parent_group() 
-	convenience method, so people do not have to use the 
-	property.
-	* demos/canvas_features.cc:
-	* demos/primitives.cc: Use get_parent_group() instead of 
-	property_parent().
-
-This is the HEAD branch. The gnome-2-10 is for maintenance of 
-libgnomecanvasmm-2.10.x.
- 
-2005-06-08  Murray Cumming  <murrayc@murrayc.com>
-
-	* libgnomecanvas/src/canvas.hg:
-	* libgnomecanvas/src/ellipse.hg:
-	* libgnomecanvas/src/group.hg: Removed extra ;s that break 
-	the build on SUN Forte CC.
-
 2.10.0:
 
 2005-02-07  Cedric Gustin  <cedric.gustin@swing.be>
diff --git a/libs/libgnomecanvasmm/NEWS b/libs/libgnomecanvasmm/NEWS
index 1585bcf267..f3bf80dcef 100644
--- a/libs/libgnomecanvasmm/NEWS
+++ b/libs/libgnomecanvasmm/NEWS
@@ -1,23 +1,3 @@
-2.16.0:
-
-* Increased version number for GNOME 2.16
-
-2.14.0:
-
-* Increased version number for GNOME 2.14
-
-2.12.0:
-
-API additions compared to 2.10:
-
-* Added Item::get_parent_group() convenience method.
-  (Murray Cumming)
-
-2.11.1:
-
-* Added Item::get_parent_group() convenience method.
-  (Murray Cumming)
-
 2.10.0:
 
 * Increased version for GNOME 2.10 release version.
diff --git a/libs/libgnomecanvasmm/SConscript b/libs/libgnomecanvasmm/SConscript
index 64d1862f17..7cab8b707a 100644
--- a/libs/libgnomecanvasmm/SConscript
+++ b/libs/libgnomecanvasmm/SConscript
@@ -15,8 +15,7 @@ gnomecanvasmm.Merge([libraries['glibmm2'],
                      libraries['atkmm'],
                      libraries['gdkmm2'],
                      libraries['gtkmm2'],
-                     libraries['libgnomecanvas2'],
-                     libraries['cairomm'] ])
+                     libraries['libgnomecanvas2'] ])
 
 libgnomecanvasmm = gnomecanvasmm.SharedLibrary('libgnomecanvasmm', gnomecanvasmm_files)
 Default(libgnomecanvasmm)
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/bpath.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.cc
index 0f0651aa15..6843922029 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/bpath.h>
 #include <libgnomecanvasmm/private/bpath_p.h>
 
@@ -39,7 +38,7 @@ Bpath::Bpath(Group& parent)
 
 void Bpath::set_bpath(const Glib::RefPtr<PathDef>& path)
 {
-  property_bpath().set_value(path->gobj());
+  property_bpath ().set_value ((gpointer)path->gobj());
 }
 
 
@@ -47,6 +46,7 @@ void Bpath::set_bpath(const Glib::RefPtr<PathDef>& path)
 
 } /* namespace Gnome */
 
+
 namespace
 {
 } // anonymous namespace
@@ -96,13 +96,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Bpath_Class::wrap_new(GObject* o)
 {
@@ -143,23 +138,15 @@ GType Bpath::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<GnomeCanvasPathDef*> Bpath::property_bpath() 
+Glib::PropertyProxy<gpointer> Bpath::property_bpath() 
 {
-  return Glib::PropertyProxy<GnomeCanvasPathDef*>(this, "bpath");
+  return Glib::PropertyProxy<gpointer>(this, "bpath");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy_ReadOnly<GnomeCanvasPathDef*> Bpath::property_bpath() const
+Glib::PropertyProxy_ReadOnly<gpointer> Bpath::property_bpath() const
 {
-  return Glib::PropertyProxy_ReadOnly<GnomeCanvasPathDef*>(this, "bpath");
+  return Glib::PropertyProxy_ReadOnly<gpointer>(this, "bpath");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.h b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.h
index 13447437eb..145b087a2e 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/bpath.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_BPATH_H
 #define _LIBGNOMECANVASMM_BPATH_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,13 +95,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -112,26 +107,22 @@ private:
 public:
   explicit Bpath(Group& parent);
 
-  //TODO: Use Glib::RefPtr<PathDef> when we can break ABI:
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  // 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<GnomeCanvasPathDef*> property_bpath() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy<gpointer> property_bpath() ;
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * 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<GnomeCanvasPathDef*> property_bpath() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy_ReadOnly<gpointer> property_bpath() const;
 
 
   void set_bpath(const Glib::RefPtr<PathDef>& path);
@@ -152,8 +143,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Bpath* wrap(GnomeCanvasBpath* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_BPATH_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.cc
index e4f23bac5c..a02ab3e580 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/canvas.h>
 #include <libgnomecanvasmm/private/canvas_p.h>
 
@@ -81,10 +80,11 @@ Art::AffineTrans Canvas::w2c_affine() const
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 
-static void Canvas_signal_draw_background_callback(GnomeCanvas* self, GdkDrawable* p0,gint p1,gint p2,gint p3,gint p4,void* data)
+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;
@@ -92,10 +92,8 @@ static void Canvas_signal_draw_background_callback(GnomeCanvas* self, GdkDrawabl
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
 , p1
@@ -103,17 +101,15 @@ static void Canvas_signal_draw_background_callback(GnomeCanvas* self, GdkDrawabl
 , p3
 , p4
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Canvas_signal_draw_background_info =
+const Glib::SignalProxyInfo Canvas_signal_draw_background_info =
 {
   "draw_background",
   (GCallback) &Canvas_signal_draw_background_callback,
@@ -121,7 +117,7 @@ static const Glib::SignalProxyInfo Canvas_signal_draw_background_info =
 };
 
 
-static void Canvas_signal_render_background_callback(GnomeCanvas* self, GnomeCanvasBuf* p0,void* data)
+void Canvas_signal_render_background_callback(GnomeCanvas* self, GnomeCanvasBuf* p0,void* data)
 {
   using namespace Gnome::Canvas;
   typedef sigc::slot< void,GnomeCanvasBuf* > SlotType;
@@ -129,23 +125,19 @@ static void Canvas_signal_render_background_callback(GnomeCanvas* self, GnomeCan
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo Canvas_signal_render_background_info =
+const Glib::SignalProxyInfo Canvas_signal_render_background_info =
 {
   "render_background",
   (GCallback) &Canvas_signal_render_background_callback,
@@ -199,14 +191,11 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->request_update = &request_update_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
   klass->draw_background = &draw_background_callback;
   klass->render_background = &render_background_callback;
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Canvas_Class::request_update_vfunc_callback(GnomeCanvas* self)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -219,19 +208,15 @@ void Canvas_Class::request_update_vfunc_callback(GnomeCanvas* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->request_update_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -245,7 +230,6 @@ void Canvas_Class::request_update_vfunc_callback(GnomeCanvas* self)
   }
 }
 
-#endif //GLIBMM_VFUNCS_ENABLED
 
 void Canvas_Class::draw_background_callback(GnomeCanvas* self, GdkDrawable* p0, gint p1, gint p2, gint p3, gint p4)
 {
@@ -259,10 +243,8 @@ void Canvas_Class::draw_background_callback(GnomeCanvas* self, GdkDrawable* p0,
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_draw_background(Glib::wrap(p0, true)
 , p1
@@ -270,13 +252,11 @@ void Canvas_Class::draw_background_callback(GnomeCanvas* self, GdkDrawable* p0,
 , p3
 , p4
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -302,19 +282,15 @@ void Canvas_Class::render_background_callback(GnomeCanvas* self, GnomeCanvasBuf*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->on_render_background(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -382,17 +358,17 @@ Group* Canvas::root() const
 
 void Canvas::set_scroll_region(double x1, double y1, double x2, double y2)
 {
-gnome_canvas_set_scroll_region(gobj(), x1, y1, x2, 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)); 
+  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)); 
+  gnome_canvas_set_center_scroll_region(gobj(), static_cast<int>(center));
 }
 
 bool Canvas::get_center_scroll_region() const
@@ -402,22 +378,22 @@ bool Canvas::get_center_scroll_region() const
 
 void Canvas::set_pixels_per_unit(double n)
 {
-gnome_canvas_set_pixels_per_unit(gobj(), n); 
+  gnome_canvas_set_pixels_per_unit(gobj(), n);
 }
 
 void Canvas::scroll_to(int x, int y)
 {
-gnome_canvas_scroll_to(gobj(), x, 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); 
+  gnome_canvas_get_scroll_offsets(const_cast<GnomeCanvas*>(gobj()), &cx, &cy);
 }
 
 void Canvas::update_now()
 {
-gnome_canvas_update_now(gobj()); 
+  gnome_canvas_update_now(gobj());
 }
 
 Item* Canvas::get_item_at(double x, double y) const
@@ -427,37 +403,37 @@ Item* Canvas::get_item_at(double x, double y) const
 
 void Canvas::request_redraw(int x1, int y1, int x2, int y2)
 {
-gnome_canvas_request_redraw(gobj(), x1, y1, x2, y2); 
+  gnome_canvas_request_redraw(gobj(), x1, y1, x2, y2);
 }
 
 void Canvas::request_redraw(ArtUta* uta)
 {
-gnome_canvas_request_redraw_uta(gobj(), 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); 
+  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)); 
+  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)); 
+  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)); 
+  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)); 
+  gnome_canvas_world_to_window(const_cast<GnomeCanvas*>(gobj()), worldx, worldy, &(winx), &(winy));
 }
 
 gulong Canvas::get_color_pixel(guint rgba) const
@@ -467,12 +443,12 @@ gulong Canvas::get_color_pixel(guint rgba) const
 
 void Canvas::set_stipple_origin(const Glib::RefPtr<Gdk::GC>& gc)
 {
-gnome_canvas_set_stipple_origin(gobj(), Glib::unwrap(gc)); 
+  gnome_canvas_set_stipple_origin(gobj(), Glib::unwrap(gc));
 }
 
 void Canvas::set_dither(Gdk::RgbDither dither)
 {
-gnome_canvas_set_dither(gobj(), ((GdkRgbDither)(dither))); 
+  gnome_canvas_set_dither(gobj(), ((GdkRgbDither)(dither)));
 }
 
 Gdk::RgbDither Canvas::get_dither() const
@@ -482,19 +458,19 @@ Gdk::RgbDither Canvas::get_dither() const
 
 void Canvas::update_svp(ArtSVP** p_svp, ArtSVP* new_svp)
 {
-gnome_canvas_update_svp(gobj(), p_svp, 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); 
+  gnome_canvas_update_svp_clip(gobj(), p_svp, new_svp, clip_svp);
 }
 
- double Canvas::get_pixels_per_unit() const
+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()
 {
@@ -507,12 +483,15 @@ Glib::SignalProxy1< void,GnomeCanvasBuf* > Canvas::signal_render_background()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+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");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
 void Gnome::Canvas::Canvas::on_draw_background(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height)
@@ -536,7 +515,6 @@ void Gnome::Canvas::Canvas::on_render_background(GnomeCanvasBuf* buf)
 }
 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Gnome::Canvas::Canvas::request_update_vfunc() 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -547,8 +525,6 @@ void Gnome::Canvas::Canvas::request_update_vfunc()
     (*base->request_update)(gobj());
 }
 
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 } // namespace Canvas
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.h b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.h
index 677736ad10..c7ee6e8d71 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/canvas.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_CANVAS_H
 #define _LIBGNOMECANVASMM_CANVAS_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -108,13 +107,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
   virtual void on_draw_background(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height);
@@ -122,7 +117,7 @@ protected:
 
 
 private:
-
+;
 public:
   Canvas();
 
@@ -383,8 +378,8 @@ public:
   // 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;
- 
+  double get_pixels_per_unit() const;
+
   //: Draw the background for the area given.
   //- This method is only used for non-antialiased canvases.
   
@@ -400,21 +395,24 @@ public:
   Glib::SignalProxy1< void,GnomeCanvasBuf* > signal_render_background();
 
   //: Private Virtual methods for groping the canvas inside bonobo.
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void request_update_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
+    virtual void request_update_vfunc();
 
   // Whether the canvas is in antialiased mode or not.
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** The antialiasing mode of the canvas.
+  /** 
+   *
+   * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -440,8 +438,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Canvas* wrap(GnomeCanvas* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_CANVAS_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.cc
index 48ddc4e883..ecc2402516 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/ellipse.h>
 #include <libgnomecanvasmm/private/ellipse_p.h>
 
@@ -49,6 +48,7 @@ Ellipse::Ellipse(Group& parentx)
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 } // anonymous namespace
@@ -98,13 +98,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Ellipse_Class::wrap_new(GObject* o)
 {
@@ -145,10 +140,6 @@ GType Ellipse::get_base_type()
 }
 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Canvas
 
 } // namespace Gnome
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.h b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.h
index bea0d01c8c..e085dc45e8 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/ellipse.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_ELLIPSE_H
 #define _LIBGNOMECANVASMM_ELLIPSE_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -99,19 +98,15 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
 
 private:
-
+;
 
 public:
   explicit Ellipse(Group& parent);
@@ -122,8 +117,6 @@ public:
 
 } /* namespace Canvas */
 } /* namespace Gnome */
-
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Ellipse
@@ -132,8 +125,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Ellipse* wrap(GnomeCanvasEllipse* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_ELLIPSE_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/group.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/group.cc
index 4ad89d23bc..90c9c97466 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/group.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/group.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/group.h>
 #include <libgnomecanvasmm/private/group_p.h>
 
@@ -43,6 +42,7 @@ Group::Group(Group& parentx, double x, double y)
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 } // anonymous namespace
@@ -92,13 +92,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Group_Class::wrap_new(GObject* o)
 {
@@ -147,37 +142,25 @@ Group::Group()
   }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Group::property_x() 
 {
   return Glib::PropertyProxy<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Group::property_x() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Group::property_y() 
 {
   return Glib::PropertyProxy<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Group::property_y() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/group.h b/libs/libgnomecanvasmm/libgnomecanvasmm/group.h
index a9516e0922..ef359297dd 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/group.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/group.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_GROUP_H
 #define _LIBGNOMECANVASMM_GROUP_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -99,64 +98,52 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
 
 private:
-
+;
 public:
   friend class Canvas;
   explicit Group(Group& parent, double x = 0, double y = 0);
   Group();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 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<double> property_x() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 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<double> property_y() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -164,7 +151,6 @@ public:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Group
@@ -173,8 +159,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Group* wrap(GnomeCanvasGroup* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_GROUP_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/item.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/item.cc
index 29bf222644..b39c34ad89 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/item.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/item.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/item.h>
 #include <libgnomecanvasmm/private/item_p.h>
 
@@ -118,35 +117,14 @@ Item::get_i2c_affine() const
   return Art::AffineTrans(tmp);
 }
 
-Group* Item::get_parent_group()
-{
-  //This is implemented in C, instead of using our C++ PropertyProxy, because uses of PropertyProxy<Object*> 
-  //do not compile with some versions of SUN Forte C++.
-
-  GValue value = { 0, };
-  g_value_init(&value, GNOME_TYPE_CANVAS_ITEM);
-  //The property is specified as ITEM, but it's actually always a GNOME_TYPE_CANVAS_GROUP.
-
-  g_object_get_property(G_OBJECT(gobj()), "parent", &value);
-
-  GnomeCanvasGroup* cgroup = GNOME_CANVAS_GROUP(g_value_get_object(&value));
-
-  return Glib::wrap(cgroup);
-}
-
-const Group* Item::get_parent_group() const
-{
-  Item* nonconstthis = const_cast<Item*>(this);
-  return nonconstthis->get_parent_group();
-}
-
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 
-static gboolean Item_signal_event_callback(GnomeCanvasItem* self, GdkEvent* p0,void* data)
+gboolean Item_signal_event_callback(GnomeCanvasItem* self, GdkEvent* p0,void* data)
 {
   using namespace Gnome::Canvas;
   typedef sigc::slot< bool,GdkEvent* > SlotType;
@@ -154,26 +132,22 @@ static gboolean Item_signal_event_callback(GnomeCanvasItem* self, GdkEvent* p0,v
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         return static_cast<int>((*static_cast<SlotType*>(slot))(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static gboolean Item_signal_event_notify_callback(GnomeCanvasItem* self, GdkEvent* p0, void* data)
+gboolean Item_signal_event_notify_callback(GnomeCanvasItem* self, GdkEvent* p0, void* data)
 {
   using namespace Gnome::Canvas;
   typedef sigc::slot< void,GdkEvent* > SlotType;
@@ -181,26 +155,22 @@ static gboolean Item_signal_event_notify_callback(GnomeCanvasItem* self, GdkEven
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
         (*static_cast<SlotType*>(slot))(p0);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 
   typedef gboolean RType;
   return RType();
 }
 
-static const Glib::SignalProxyInfo Item_signal_event_info =
+const Glib::SignalProxyInfo Item_signal_event_info =
 {
   "event",
   (GCallback) &Item_signal_event_callback,
@@ -254,7 +224,6 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
   klass->update = &update_vfunc_callback;
   klass->realize = &realize_vfunc_callback;
   klass->unrealize = &unrealize_vfunc_callback;
@@ -265,11 +234,9 @@ void Item_Class::class_init_function(void* g_class, void* class_data)
   klass->render = &render_vfunc_callback;
   klass->point = &point_vfunc_callback;
   klass->bounds = &bounds_vfunc_callback;
-#endif //GLIBMM_VFUNCS_ENABLED
   klass->event = &event_callback;
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Item_Class::update_vfunc_callback(GnomeCanvasItem* self, double* affine, ArtSVP* clip_path, int flags)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
@@ -282,19 +249,15 @@ void Item_Class::update_vfunc_callback(GnomeCanvasItem* self, double* affine, Ar
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->update_vfunc(affine, clip_path, flags);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -320,19 +283,15 @@ void Item_Class::realize_vfunc_callback(GnomeCanvasItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->realize_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -358,19 +317,15 @@ void Item_Class::unrealize_vfunc_callback(GnomeCanvasItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->unrealize_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -396,19 +351,15 @@ void Item_Class::map_vfunc_callback(GnomeCanvasItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->map_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -434,19 +385,15 @@ void Item_Class::unmap_vfunc_callback(GnomeCanvasItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->unmap_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -472,19 +419,15 @@ ArtUta* Item_Class::coverage_vfunc_callback(GnomeCanvasItem* self)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->coverage_vfunc();
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -513,20 +456,16 @@ void Item_Class::draw_vfunc_callback(GnomeCanvasItem* self, GdkDrawable* drawabl
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->draw_vfunc(Glib::wrap(drawable, true)
 , x, y, width, height);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -552,19 +491,15 @@ void Item_Class::render_vfunc_callback(GnomeCanvasItem* self, GnomeCanvasBuf* bu
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->render_vfunc(buf);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -590,19 +525,15 @@ double Item_Class::point_vfunc_callback(GnomeCanvasItem* self, double x, double
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return obj->point_vfunc(x, y, cx, cy, actual_item);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -631,19 +562,15 @@ void Item_Class::bounds_vfunc_callback(GnomeCanvasItem* self, double* x1, double
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       obj->bounds_vfunc(x1, y1, x2, y2);
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -657,7 +584,6 @@ void Item_Class::bounds_vfunc_callback(GnomeCanvasItem* self, double* x1, double
   }
 }
 
-#endif //GLIBMM_VFUNCS_ENABLED
 
 gboolean Item_Class::event_callback(GnomeCanvasItem* self, GdkEvent* p0)
 {
@@ -671,19 +597,15 @@ gboolean Item_Class::event_callback(GnomeCanvasItem* self, GdkEvent* p0)
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
       return static_cast<int>(obj->on_event(p0));
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -742,102 +664,102 @@ GType Item::get_base_type()
 
 void Item::move(double dx, double dy)
 {
-gnome_canvas_item_move(gobj(), dx, dy); 
+  gnome_canvas_item_move(gobj(), dx, dy);
 }
 
 void Item::raise(int positions)
 {
-gnome_canvas_item_raise(gobj(), positions); 
+  gnome_canvas_item_raise(gobj(), positions);
 }
 
 void Item::lower(int positions)
 {
-gnome_canvas_item_lower(gobj(), positions); 
+  gnome_canvas_item_lower(gobj(), positions);
 }
 
 void Item::raise_to_top()
 {
-gnome_canvas_item_raise_to_top(gobj()); 
+  gnome_canvas_item_raise_to_top(gobj());
 }
 
 void Item::lower_to_bottom()
 {
-gnome_canvas_item_lower_to_bottom(gobj()); 
+  gnome_canvas_item_lower_to_bottom(gobj());
 }
 
 void Item::ungrab(guint32 etime)
 {
-gnome_canvas_item_ungrab(gobj(), etime); 
+  gnome_canvas_item_ungrab(gobj(), etime);
 }
 
 void Item::w2i(double& x, double& y)
 {
-gnome_canvas_item_w2i(gobj(), &(x), &(y)); 
+  gnome_canvas_item_w2i(gobj(), &(x), &(y));
 }
 
 void Item::i2w(double& x, double& y)
 {
-gnome_canvas_item_i2w(gobj(), &(x), &(y)); 
+  gnome_canvas_item_i2w(gobj(), &(x), &(y));
 }
 
 void Item::grab_focus()
 {
-gnome_canvas_item_grab_focus(gobj()); 
+  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)); 
+  gnome_canvas_item_get_bounds(const_cast<GnomeCanvasItem*>(gobj()), &(x1), &(y1), &(x2), &(y2));
 }
 
 void Item::show()
 {
-gnome_canvas_item_show(gobj()); 
+  gnome_canvas_item_show(gobj());
 }
 
 void Item::hide()
 {
-gnome_canvas_item_hide(gobj()); 
+  gnome_canvas_item_hide(gobj());
 }
 
 void Item::reparent(Group& new_group)
 {
-gnome_canvas_item_reparent(gobj(), (new_group).gobj()); 
+  gnome_canvas_item_reparent(gobj(), (new_group).gobj());
 }
 
- Canvas* Item::get_canvas() const
+Canvas* Item::get_canvas() const
 {
   return Glib::wrap(gobj()->canvas);
 }
- 
+
 void Item::request_update()
 {
-gnome_canvas_item_request_update(gobj()); 
+  gnome_canvas_item_request_update(gobj());
 }
 
 void Item::reset_bounds()
 {
-gnome_canvas_item_reset_bounds(gobj()); 
+  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); 
+  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); 
+  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); 
+  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); 
+  gnome_canvas_update_bbox(gobj(), x1, y1, x2, y2);
 }
 
 
@@ -847,19 +769,15 @@ Glib::SignalProxy1< bool,GdkEvent* > Item::signal_event()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Group*> Item::property_parent() 
 {
   return Glib::PropertyProxy<Group*>(this, "parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Group*> Item::property_parent() const
 {
   return Glib::PropertyProxy_ReadOnly<Group*>(this, "parent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
 bool Gnome::Canvas::Item::on_event(GdkEvent* p1)
@@ -876,7 +794,6 @@ bool Gnome::Canvas::Item::on_event(GdkEvent* p1)
 }
 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
 void Gnome::Canvas::Item::update_vfunc(double* affine, ArtSVP* clip_path, int flags) 
 {
   BaseClassType *const base = static_cast<BaseClassType*>(
@@ -983,8 +900,6 @@ void Gnome::Canvas::Item::bounds_vfunc(double* x1, double* y1, double* x2, doubl
     (*base->bounds)(gobj(),x1,y1,x2,y2);
 }
 
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 } // namespace Canvas
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/item.h b/libs/libgnomecanvasmm/libgnomecanvasmm/item.h
index 8c32b98f1f..9265b2018f 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/item.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/item.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_ITEM_H
 #define _LIBGNOMECANVASMM_ITEM_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -106,13 +105,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
   virtual bool on_event(GdkEvent* p1);
@@ -263,48 +258,18 @@ public:
   void reparent(Group& new_group);
 
   /// Returns the canvas we're on.
-   Canvas* get_canvas() const;
- 
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void update_vfunc(double* affine, ArtSVP* clip_path, int flags);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void realize_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void unrealize_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void map_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void unmap_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual ArtUta* coverage_vfunc();
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void draw_vfunc(const Glib::RefPtr<Gdk::Drawable>& drawable, int x, int y, int width, int height);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void render_vfunc(GnomeCanvasBuf* buf);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual double point_vfunc(double x, double y, int cx, int cy, GnomeCanvasItem** actual_item);
-#endif //GLIBMM_VFUNCS_ENABLED
-
-  #ifdef GLIBMM_VFUNCS_ENABLED
-  virtual void bounds_vfunc(double* x1, double* y1, double* x2, double* y2);
-#endif //GLIBMM_VFUNCS_ENABLED
-
+  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.
@@ -313,20 +278,14 @@ public:
   Glib::SignalProxy1< bool,GdkEvent* > signal_event();
 
 
-  Group* get_parent_group();
-  const Group* get_parent_group() const;
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -334,7 +293,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Group*> property_parent() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 protected:
@@ -399,7 +357,6 @@ protected:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Item
@@ -408,8 +365,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Item* wrap(GnomeCanvasItem* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_ITEM_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/line.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/line.cc
index 62f9a933d3..5b12c69ba6 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/line.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/line.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/line.h>
 #include <libgnomecanvasmm/private/line_p.h>
 
@@ -119,6 +118,7 @@ GType Glib::Value<Gnome::Canvas::Points>::value_type()
   return Gnome::Canvas::Points::get_type();
 }
 
+
 namespace
 {
 } // anonymous namespace
@@ -168,13 +168,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Line_Class::wrap_new(GObject* o)
 {
@@ -215,247 +210,175 @@ GType Line::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Points> Line::property_points() 
 {
   return Glib::PropertyProxy<Points>(this, "points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Points> Line::property_points() const
 {
   return Glib::PropertyProxy_ReadOnly<Points>(this, "points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Line::property_fill_color() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "fill-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Line::property_fill_color() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "fill-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::Color> Line::property_fill_color_gdk() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "fill-color-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> Line::property_fill_color_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "fill-color-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Line::property_fill_color_rgba() 
 {
   return Glib::PropertyProxy<guint>(this, "fill-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Line::property_fill_color_rgba() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "fill-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Line::property_fill_stipple() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Line::property_fill_stipple() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Line::property_width_pixels() 
 {
   return Glib::PropertyProxy<guint>(this, "width-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Line::property_width_pixels() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "width-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Line::property_width_units() 
 {
   return Glib::PropertyProxy<double>(this, "width-units");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Line::property_width_units() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "width-units");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::CapStyle> Line::property_cap_style() 
 {
   return Glib::PropertyProxy<Gdk::CapStyle>(this, "cap-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> Line::property_cap_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::CapStyle>(this, "cap-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::JoinStyle> Line::property_join_style() 
 {
   return Glib::PropertyProxy<Gdk::JoinStyle>(this, "join-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> Line::property_join_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle>(this, "join-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::LineStyle> Line::property_line_style() 
 {
   return Glib::PropertyProxy<Gdk::LineStyle>(this, "line-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::LineStyle> Line::property_line_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::LineStyle>(this, "line-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Line::property_first_arrowhead() 
 {
   return Glib::PropertyProxy<bool>(this, "first-arrowhead");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Line::property_first_arrowhead() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "first-arrowhead");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Line::property_last_arrowhead() 
 {
   return Glib::PropertyProxy<bool>(this, "last-arrowhead");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Line::property_last_arrowhead() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "last-arrowhead");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Line::property_smooth() 
 {
   return Glib::PropertyProxy<bool>(this, "smooth");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Line::property_smooth() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "smooth");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Line::property_spline_steps() 
 {
   return Glib::PropertyProxy<guint>(this, "spline-steps");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Line::property_spline_steps() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "spline-steps");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Line::property_arrow_shape_a() 
 {
   return Glib::PropertyProxy<double>(this, "arrow-shape-a");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Line::property_arrow_shape_a() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "arrow-shape-a");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Line::property_arrow_shape_b() 
 {
   return Glib::PropertyProxy<double>(this, "arrow-shape-b");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Line::property_arrow_shape_b() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "arrow-shape-b");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Line::property_arrow_shape_c() 
 {
   return Glib::PropertyProxy<double>(this, "arrow-shape-c");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Line::property_arrow_shape_c() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "arrow-shape-c");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/line.h b/libs/libgnomecanvasmm/libgnomecanvasmm/line.h
index 30f6327c69..ab792c8abd 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/line.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/line.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_LINE_H
 #define _LIBGNOMECANVASMM_LINE_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -143,13 +142,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -160,17 +155,14 @@ public:
   explicit Line(Group& parent);
   Line(Group& parent, const Points& points);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -178,19 +170,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Points> property_points() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -198,19 +186,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Glib::ustring> property_fill_color() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -218,19 +202,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_fill_color_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -238,19 +218,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_fill_color_rgba() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -258,19 +234,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -278,19 +250,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_width_pixels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -298,19 +266,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_width_units() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -318,19 +282,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> property_cap_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -338,19 +298,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> property_join_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -358,19 +314,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::LineStyle> property_line_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -378,19 +330,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_first_arrowhead() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -398,19 +346,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_last_arrowhead() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -418,19 +362,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_smooth() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -438,19 +378,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_spline_steps() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -458,19 +394,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_a() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -478,19 +410,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_b() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -498,7 +426,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_arrow_shape_c() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -521,7 +448,6 @@ public:
 } // namespace Glib
 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Line
@@ -530,8 +456,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Line* wrap(GnomeCanvasLine* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_LINE_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.cc
index 7f907ffd49..528c3f8153 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/path-def.h>
 #include <libgnomecanvasmm/private/path-def_p.h>
 
@@ -40,6 +39,7 @@ Gnome::Art::Point PathDef::currentpoint() const
 } /* namespace Canvas */
 
 } /* namespace Gnome */
+
 namespace
 {
 } // anonymous namespace
@@ -148,47 +148,47 @@ Glib::RefPtr<PathDef> PathDef::close_all()
 
 void PathDef::finish()
 {
-gnome_canvas_path_def_finish(gobj()); 
+  gnome_canvas_path_def_finish(gobj());
 }
 
 void PathDef::ensure_space(int space)
 {
-gnome_canvas_path_def_ensure_space(gobj(), space); 
+  gnome_canvas_path_def_ensure_space(gobj(), space);
 }
 
 void PathDef::reset()
 {
-gnome_canvas_path_def_reset(gobj()); 
+  gnome_canvas_path_def_reset(gobj());
 }
 
 void PathDef::moveto(double x, double y)
 {
-gnome_canvas_path_def_moveto(gobj(), x, y); 
+  gnome_canvas_path_def_moveto(gobj(), x, y);
 }
 
 void PathDef::lineto(double x, double y)
 {
-gnome_canvas_path_def_lineto(gobj(), x, 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); 
+  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); 
+  gnome_canvas_path_def_curveto(gobj(), x1, y1, x2, y2, x3, y3);
 }
 
 void PathDef::closepath()
 {
-gnome_canvas_path_def_closepath(gobj()); 
+  gnome_canvas_path_def_closepath(gobj());
 }
 
 void PathDef::closepath_current()
 {
-gnome_canvas_path_def_closepath_current(gobj()); 
+  gnome_canvas_path_def_closepath_current(gobj());
 }
 
 ArtBpath* PathDef::get_bpath() const
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.h b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.h
index c092793298..4f528f5806 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/path-def.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_PATH_DEF_H
 #define _LIBGNOMECANVASMM_PATH_DEF_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -281,6 +280,5 @@ namespace Glib
 
 } // namespace Glib
 
-
 #endif /* _LIBGNOMECANVASMM_PATH_DEF_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.cc
index adc4f13640..c0b49a70dc 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/pixbuf.h>
 #include <libgnomecanvasmm/private/pixbuf_p.h>
 
@@ -108,13 +107,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Pixbuf_Class::wrap_new(GObject* o)
 {
@@ -155,177 +149,125 @@ GType Pixbuf::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> > Pixbuf::property_pixbuf() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > Pixbuf::property_pixbuf() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> >(this, "pixbuf");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Pixbuf::property_width() 
 {
   return Glib::PropertyProxy<double>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_width() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Pixbuf::property_width_set() 
 {
   return Glib::PropertyProxy<bool>(this, "width-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_width_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "width-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Pixbuf::property_width_in_pixels() 
 {
   return Glib::PropertyProxy<bool>(this, "width-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_width_in_pixels() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "width-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Pixbuf::property_height() 
 {
   return Glib::PropertyProxy<double>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_height() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Pixbuf::property_height_set() 
 {
   return Glib::PropertyProxy<bool>(this, "height-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_height_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "height-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Pixbuf::property_height_in_pixels() 
 {
   return Glib::PropertyProxy<bool>(this, "height-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_height_in_pixels() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "height-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Pixbuf::property_x() 
 {
   return Glib::PropertyProxy<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_x() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Pixbuf::property_x_in_pixels() 
 {
   return Glib::PropertyProxy<bool>(this, "x-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_x_in_pixels() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "x-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Pixbuf::property_y() 
 {
   return Glib::PropertyProxy<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Pixbuf::property_y() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Pixbuf::property_y_in_pixels() 
 {
   return Glib::PropertyProxy<bool>(this, "y-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Pixbuf::property_y_in_pixels() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "y-in-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::AnchorType> Pixbuf::property_anchor() 
 {
   return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> Pixbuf::property_anchor() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.h b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.h
index b470e3e1db..6b7922318e 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/pixbuf.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_PIXBUF_H
 #define _LIBGNOMECANVASMM_PIXBUF_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -98,13 +97,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -115,17 +110,14 @@ public:
   Pixbuf(Group& parent, double x, double y, const Glib::RefPtr<Gdk::Pixbuf>& image);
   explicit Pixbuf(Group& parent);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -133,19 +125,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -153,19 +141,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -173,19 +157,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_width_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -193,19 +173,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_width_in_pixels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -213,19 +189,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -233,19 +205,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_height_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -253,19 +221,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_height_in_pixels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -273,19 +237,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_x() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -293,19 +253,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_x_in_pixels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -313,19 +269,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_y() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -333,19 +285,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_y_in_pixels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -353,7 +301,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> property_anchor() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -361,7 +308,6 @@ public:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Pixbuf
@@ -370,8 +316,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Pixbuf* wrap(GnomeCanvasPixbuf* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_PIXBUF_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.cc
index 733f40b4a6..08eb1b60bc 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/polygon.h>
 #include <libgnomecanvasmm/private/polygon_p.h>
 
@@ -97,13 +96,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Polygon_Class::wrap_new(GObject* o)
 {
@@ -144,23 +138,15 @@ GType Polygon::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Points> Polygon::property_points() 
 {
   return Glib::PropertyProxy<Points>(this, "points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Points> Polygon::property_points() const
 {
   return Glib::PropertyProxy_ReadOnly<Points>(this, "points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.h b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.h
index 69c04be71f..1d6dad5e55 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/polygon.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_POLYGON_H
 #define _LIBGNOMECANVASMM_POLYGON_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -96,13 +95,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -113,17 +108,14 @@ public:
   Polygon(Group& parent, const Points& points);
   explicit Polygon(Group& parent);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -131,7 +123,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Points> property_points() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -148,8 +139,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Polygon* wrap(GnomeCanvasPolygon* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_POLYGON_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/private/bpath_p.h b/libs/libgnomecanvasmm/libgnomecanvasmm/private/bpath_p.h
index 897cc84bb2..4c6d727306 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/bpath_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/bpath_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index e042f0c010..48b08937c5 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/canvas_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/canvas_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -42,9 +40,7 @@ protected:
   static void render_background_callback(GnomeCanvas* self, GnomeCanvasBuf* p0);
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   static void request_update_vfunc_callback(GnomeCanvas* self);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -52,6 +48,5 @@ protected:
 
 } // 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
index 20011b3d94..513b1a945c 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/ellipse_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/ellipse_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index 3d9787049b..95a2ecff44 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/group_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/group_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index 27eee31991..d898eb8304 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/item_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/item_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -41,7 +39,6 @@ protected:
   static gboolean event_callback(GnomeCanvasItem* self, GdkEvent* p0);
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
   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);
@@ -52,7 +49,6 @@ protected:
   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);
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -60,6 +56,5 @@ protected:
 
 } // 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
index 962fc96436..819ad6ee7c 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/line_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/line_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index 18d4d97ca0..b7ccc3f278 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/path-def_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/path-def_p.h
@@ -2,7 +2,5 @@
 // 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
index 99948eb48b..54e464677a 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/pixbuf_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/pixbuf_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index a8cf7bb60f..2ca067cf7b 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/polygon_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/polygon_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index fee92dfe02..73913352bb 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect-ellipse_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect-ellipse_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index 2041ac1a42..a42c84fd15 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rect_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index a5ef4b778a..90fa63a557 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/rich-text_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/rich-text_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -38,11 +36,9 @@ 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* p0);
+  static void tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag* tag);
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -50,6 +46,5 @@ protected:
 
 } // 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
index fe010aef6a..f0fac4d6f2 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/shape_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/shape_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index f62f3627bf..f15e8e5a50 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/text_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/text_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // 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
index 6b7ff7658d..22fede33de 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/private/widget_p.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/private/widget_p.h
@@ -2,8 +2,6 @@
 // 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>
@@ -40,8 +38,6 @@ protected:
   //You could prevent the original default signal handlers being called by overriding the *_impl method.
 
   //Callbacks (virtual functions):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 };
 
 
@@ -49,6 +45,5 @@ protected:
 
 } // namespace Gnome
 
-
 #endif /* _LIBGNOMECANVASMM_WIDGET_P_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.cc
index 09deadeb5b..2733963ce0 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/rect-ellipse.h>
 #include <libgnomecanvasmm/private/rect-ellipse_p.h>
 
@@ -41,6 +40,7 @@ RectEllipse::RectEllipse(Group& parent)
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 } // anonymous namespace
@@ -90,13 +90,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* RectEllipse_Class::wrap_new(GObject* o)
 {
@@ -137,65 +132,45 @@ GType RectEllipse::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RectEllipse::property_x1() 
 {
   return Glib::PropertyProxy<double>(this, "x1");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_x1() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x1");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RectEllipse::property_y1() 
 {
   return Glib::PropertyProxy<double>(this, "y1");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_y1() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y1");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RectEllipse::property_x2() 
 {
   return Glib::PropertyProxy<double>(this, "x2");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_x2() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x2");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RectEllipse::property_y2() 
 {
   return Glib::PropertyProxy<double>(this, "y2");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RectEllipse::property_y2() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y2");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.h b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.h
index 4c3a43963b..9982ce34b2 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect-ellipse.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_RECT_ELLIPSE_H
 #define _LIBGNOMECANVASMM_RECT_ELLIPSE_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -102,13 +101,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -118,17 +113,14 @@ private:
 public:
   explicit RectEllipse(Group& parent);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -136,19 +128,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_x1() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -156,19 +144,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_y1() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -176,19 +160,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_x2() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -196,7 +176,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_y2() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -204,7 +183,6 @@ public:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::RectEllipse
@@ -213,8 +191,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::RectEllipse* wrap(GnomeCanvasRE* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_RECT_ELLIPSE_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.cc
index 080cc6d924..68bc53a756 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/rect.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/rect.h>
 #include <libgnomecanvasmm/private/rect_p.h>
 
@@ -48,6 +47,7 @@ Rect::Rect(Group& parentx)
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 } // anonymous namespace
@@ -97,13 +97,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Rect_Class::wrap_new(GObject* o)
 {
@@ -144,10 +139,6 @@ GType Rect::get_base_type()
 }
 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Canvas
 
 } // namespace Gnome
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rect.h b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.h
index a06513f8d5..cebd0c4655 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/rect.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rect.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_RECT_H
 #define _LIBGNOMECANVASMM_RECT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -100,13 +99,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -124,7 +119,6 @@ public:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Rect
@@ -133,8 +127,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Rect* wrap(GnomeCanvasRect* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_RECT_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.cc
index 3645b84fc8..87978b2b1b 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/rich-text.h>
 #include <libgnomecanvasmm/private/rich-text_p.h>
 
@@ -66,7 +65,7 @@ RichText::iterator RichText::get_iter_at_location(int x, int y) const
 namespace
 {
 
-static void RichText_signal_tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag* p0,void* data)
+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;
@@ -74,24 +73,20 @@ static void RichText_signal_tag_changed_callback(GnomeCanvasRichText* self, GtkT
   // Do not try to call a signal on a disassociated wrapper.
   if(Glib::ObjectBase::_get_current_wrapper((GObject*) self))
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       if(sigc::slot_base *const slot = Glib::SignalProxyNormal::data_to_slot(data))
-        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
+        (*static_cast<SlotType*>(slot))(Glib::wrap(tag, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
 }
 
-static const Glib::SignalProxyInfo RichText_signal_tag_changed_info =
+const Glib::SignalProxyInfo RichText_signal_tag_changed_info =
 {
   "tag_changed",
   (GCallback) &RichText_signal_tag_changed_callback,
@@ -145,15 +140,11 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
   klass->tag_changed = &tag_changed_callback;
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
-void RichText_Class::tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag* p0)
+void RichText_Class::tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag* tag)
 {
   CppObjectType *const obj = dynamic_cast<CppObjectType*>(
       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
@@ -165,20 +156,16 @@ void RichText_Class::tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag*
   // being overridden:
   if(obj && obj->is_derived_())
   {
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     try // Trap C++ exceptions which would normally be lost because this is a C callback.
     {
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
       // Call the virtual member method, which derived classes might override.
-      obj->on_tag_changed(Glib::wrap(p0, true)
+      obj->on_tag_changed(Glib::wrap(tag, true)
 );
-    #ifdef GLIBMM_EXCEPTIONS_ENABLED
     }
     catch(...)
     {
       Glib::exception_handlers_invoke();
     }
-    #endif //GLIBMM_EXCEPTIONS_ENABLED
   }
   else
   {
@@ -188,7 +175,7 @@ void RichText_Class::tag_changed_callback(GnomeCanvasRichText* self, GtkTextTag*
 
     // Call the original underlying C function:
     if(base && base->tag_changed)
-      (*base->tag_changed)(self, p0);
+      (*base->tag_changed)(self, tag);
   }
 }
 
@@ -234,22 +221,22 @@ GType RichText::get_base_type()
 
 void RichText::cut_clipboard()
 {
-gnome_canvas_rich_text_cut_clipboard(gobj()); 
+  gnome_canvas_rich_text_cut_clipboard(gobj());
 }
 
 void RichText::copy_clipboard()
 {
-gnome_canvas_rich_text_copy_clipboard(gobj()); 
+  gnome_canvas_rich_text_copy_clipboard(gobj());
 }
 
 void RichText::paste_clipboard()
 {
-gnome_canvas_rich_text_paste_clipboard(gobj()); 
+  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)); 
+  gnome_canvas_rich_text_set_buffer(gobj(), Glib::unwrap(buffer));
 }
 
 Glib::RefPtr<Gtk::TextBuffer> RichText::get_buffer() const
@@ -259,7 +246,7 @@ Glib::RefPtr<Gtk::TextBuffer> RichText::get_buffer() const
 
 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()); 
+  gnome_canvas_rich_text_get_iter_location(const_cast<GnomeCanvasRichText*>(gobj()), (iter).gobj(), (location).gobj());
 }
 
 
@@ -269,285 +256,205 @@ Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::TextTag>& > RichText::signal_ta
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> RichText::property_text() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> RichText::property_text() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RichText::property_x() 
 {
   return Glib::PropertyProxy<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RichText::property_x() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RichText::property_y() 
 {
   return Glib::PropertyProxy<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RichText::property_y() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RichText::property_width() 
 {
   return Glib::PropertyProxy<double>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RichText::property_width() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> RichText::property_height() 
 {
   return Glib::PropertyProxy<double>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> RichText::property_height() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> RichText::property_editable() 
 {
   return Glib::PropertyProxy<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> RichText::property_editable() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "editable");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> RichText::property_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> RichText::property_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> RichText::property_cursor_visible() 
 {
   return Glib::PropertyProxy<bool>(this, "cursor-visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> RichText::property_cursor_visible() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "cursor-visible");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> RichText::property_cursor_blink() 
 {
   return Glib::PropertyProxy<bool>(this, "cursor-blink");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> RichText::property_cursor_blink() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "cursor-blink");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> RichText::property_grow_height() 
 {
   return Glib::PropertyProxy<bool>(this, "grow-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> RichText::property_grow_height() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "grow-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::WrapMode> RichText::property_wrap_mode() 
 {
   return Glib::PropertyProxy<Gtk::WrapMode>(this, "wrap-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::WrapMode> RichText::property_wrap_mode() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::WrapMode>(this, "wrap-mode");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Justification> RichText::property_justification() 
 {
   return Glib::PropertyProxy<Gtk::Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Justification> RichText::property_justification() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::DirectionType> RichText::property_direction() 
 {
   return Glib::PropertyProxy<Gtk::DirectionType>(this, "direction");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::DirectionType> RichText::property_direction() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::DirectionType>(this, "direction");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::AnchorType> RichText::property_anchor() 
 {
   return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> RichText::property_anchor() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> RichText::property_pixels_above_lines() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-above-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> RichText::property_pixels_above_lines() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-above-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> RichText::property_pixels_below_lines() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-below-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> RichText::property_pixels_below_lines() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-below-lines");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> RichText::property_pixels_inside_wrap() 
 {
   return Glib::PropertyProxy<int>(this, "pixels-inside-wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> RichText::property_pixels_inside_wrap() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "pixels-inside-wrap");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> RichText::property_left_margin() 
 {
   return Glib::PropertyProxy<int>(this, "left-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> RichText::property_left_margin() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "left-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> RichText::property_right_margin() 
 {
   return Glib::PropertyProxy<int>(this, "right-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> RichText::property_right_margin() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "right-margin");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> RichText::property_indent() 
 {
   return Glib::PropertyProxy<int>(this, "indent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> RichText::property_indent() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "indent");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
 
 void Gnome::Canvas::RichText::on_tag_changed(const Glib::RefPtr<Gtk::TextTag>& tag)
@@ -561,10 +468,6 @@ void Gnome::Canvas::RichText::on_tag_changed(const Glib::RefPtr<Gtk::TextTag>& t
 }
 
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
-
 } // namespace Canvas
 
 } // namespace Gnome
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h
index acd8a8d9e4..32af1680e4 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/rich-text.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_RICH_TEXT_H
 #define _LIBGNOMECANVASMM_RICH_TEXT_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -97,13 +96,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
   virtual void on_tag_changed(const Glib::RefPtr<Gtk::TextTag>& tag);
@@ -138,405 +133,325 @@ public:
   Glib::SignalProxy1< void,const Glib::RefPtr<Gtk::TextTag>& > signal_tag_changed();
 
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text to display.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text to display.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** X position.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** X position.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Y position.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Y position.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width for text box.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width for text box.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Height for text box.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Height for text box.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is this rich text item 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<bool> property_editable() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is this rich text item 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is this rich text item 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<bool> property_visible() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is this rich text item 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is the cursor visible in this rich text item?.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Is the cursor visible in this rich text item?.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Does the cursor blink in this rich text item?.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Does the cursor blink in this rich text item?.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Should the text box height grow if the text does not fit?.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Should the text box height grow if the text does not fit?.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Wrap mode for multiline 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<Gtk::WrapMode> property_wrap_mode() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Wrap mode for multiline 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<Gtk::WrapMode> property_wrap_mode() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Justification 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<Gtk::Justification> property_justification() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Justification 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::Justification> property_justification() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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<Gtk::DirectionType> property_direction() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Anchor point for 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<Gtk::AnchorType> property_anchor() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Anchor point for 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<Gtk::AnchorType> property_anchor() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels to put 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<int> property_pixels_above_lines() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels to put 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels to put 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<int> property_pixels_below_lines() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels to put 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels to put inside the 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<int> property_pixels_inside_wrap() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels to put inside the 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels in the 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<int> property_left_margin() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels in the 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels in the 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<int> property_right_margin() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels in the 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels for indentation.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Number of pixels for indentation.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -544,7 +459,6 @@ public:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::RichText
@@ -553,8 +467,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::RichText* wrap(GnomeCanvasRichText* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_RICH_TEXT_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/shape.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.cc
index 971b5ed49e..98dedc0cf8 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/shape.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/shape.h>
 #include <libgnomecanvasmm/private/shape_p.h>
 
@@ -73,13 +72,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Shape_Class::wrap_new(GObject* o)
 {
@@ -120,205 +114,155 @@ GType Shape::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> Shape::property_fill_color() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "fill-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+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");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> Shape::property_fill_color_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "fill-color-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Shape::property_fill_color_rgba() 
 {
   return Glib::PropertyProxy<guint>(this, "fill-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Shape::property_fill_color_rgba() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "fill-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> Shape::property_outline_color() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "outline-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+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");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> Shape::property_outline_color_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "outline-color-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Shape::property_outline_color_rgba() 
 {
   return Glib::PropertyProxy<guint>(this, "outline-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Shape::property_outline_color_rgba() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "outline-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Shape::property_fill_stipple() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Shape::property_fill_stipple() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Shape::property_outline_stipple() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "outline-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Shape::property_outline_stipple() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "outline-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Shape::property_width_pixels() 
 {
   return Glib::PropertyProxy<guint>(this, "width-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Shape::property_width_pixels() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "width-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-Glib::PropertyProxy<double> Shape::property_width_units() 
+Glib::PropertyProxy_WriteOnly<double> Shape::property_width_units() 
 {
-  return Glib::PropertyProxy<double>(this, "width-units");
+  return Glib::PropertyProxy_WriteOnly<double>(this, "width-units");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Shape::property_width_units() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "width-units");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::CapStyle> Shape::property_cap_style() 
 {
   return Glib::PropertyProxy<Gdk::CapStyle>(this, "cap-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> Shape::property_cap_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::CapStyle>(this, "cap-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::JoinStyle> Shape::property_join_style() 
 {
   return Glib::PropertyProxy<Gdk::JoinStyle>(this, "join-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> Shape::property_join_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle>(this, "join-style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Shape::property_wind() 
 {
   return Glib::PropertyProxy<guint>(this, "wind");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Shape::property_wind() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "wind");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Shape::property_miterlimit() 
 {
   return Glib::PropertyProxy<double>(this, "miterlimit");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Shape::property_miterlimit() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "miterlimit");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<ArtVpathDash*> Shape::property_dash() 
 {
   return Glib::PropertyProxy<ArtVpathDash*>(this, "dash");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<ArtVpathDash*> Shape::property_dash() const
 {
   return Glib::PropertyProxy_ReadOnly<ArtVpathDash*>(this, "dash");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/shape.h b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.h
index ba588ef6c7..e1ff6e84f0 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/shape.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/shape.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_SHAPE_H
 #define _LIBGNOMECANVASMM_SHAPE_H
 
-
 #include <glibmm.h>
 
 // -*- C++ -*-
@@ -97,13 +96,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -113,28 +108,30 @@ private:
   
 public:
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -142,19 +139,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_fill_color_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -162,30 +155,31 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_fill_color_rgba() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
-
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -193,19 +187,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::Color> property_outline_color_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -213,19 +203,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_outline_color_rgba() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -233,19 +219,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -253,19 +235,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_outline_stipple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -273,19 +251,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_width_pixels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
+  Glib::PropertyProxy_WriteOnly<double> property_width_units() ;
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -293,19 +267,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_width_units() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -313,19 +283,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::CapStyle> property_cap_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -333,19 +299,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gdk::JoinStyle> property_join_style() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -353,19 +315,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<guint> property_wind() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -373,19 +331,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_miterlimit() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -393,7 +347,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<ArtVpathDash*> property_dash() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
  //TODO: Look at ArtVpathDash to see if it should be wrapped.
 
 
@@ -402,7 +355,6 @@ public:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Shape
@@ -411,8 +363,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Shape* wrap(GnomeCanvasShape* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_SHAPE_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/text.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/text.cc
index 131313f417..62ccc4b981 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/text.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/text.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/text.h>
 #include <libgnomecanvasmm/private/text_p.h>
 
@@ -48,6 +47,7 @@ Text::Text(Group& parentx)
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 } // anonymous namespace
@@ -97,13 +97,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Text_Class::wrap_new(GObject* o)
 {
@@ -144,576 +139,415 @@ GType Text::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Text::property_text() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_text() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "text");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_WriteOnly<Glib::ustring> Text::property_markup() 
 {
   return Glib::PropertyProxy_WriteOnly<Glib::ustring>(this, "markup");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
+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");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_x() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_y() 
 {
   return Glib::PropertyProxy<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_y() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Text::property_font() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_font() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "font");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::FontDescription> Text::property_font_desc() 
 {
   return Glib::PropertyProxy<Pango::FontDescription>(this, "font-desc");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::FontDescription> Text::property_font_desc() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::FontDescription>(this, "font-desc");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Text::property_family() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "family");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_family() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "family");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_family_set() 
 {
   return Glib::PropertyProxy<bool>(this, "family-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_family_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "family-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::AttrList> Text::property_attributes() 
 {
   return Glib::PropertyProxy<Pango::AttrList>(this, "attributes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::AttrList> Text::property_attributes() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::AttrList>(this, "attributes");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Style> Text::property_style() 
 {
   return Glib::PropertyProxy<Pango::Style>(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Style> Text::property_style() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Style>(this, "style");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_style_set() 
 {
   return Glib::PropertyProxy<bool>(this, "style-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_style_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "style-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Variant> Text::property_variant() 
 {
   return Glib::PropertyProxy<Pango::Variant>(this, "variant");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Variant> Text::property_variant() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Variant>(this, "variant");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_variant_set() 
 {
   return Glib::PropertyProxy<bool>(this, "variant-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_variant_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "variant-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Text::property_weight() 
 {
   return Glib::PropertyProxy<int>(this, "weight");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Text::property_weight() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "weight");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_weight_set() 
 {
   return Glib::PropertyProxy<bool>(this, "weight-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_weight_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "weight-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Weight> Text::property_stretch() 
 {
   return Glib::PropertyProxy<Pango::Weight>(this, "stretch");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Weight> Text::property_stretch() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Weight>(this, "stretch");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_stretch_set() 
 {
   return Glib::PropertyProxy<bool>(this, "stretch-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_stretch_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "stretch-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Text::property_size() 
 {
   return Glib::PropertyProxy<int>(this, "size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Text::property_size() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "size");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_size_set() 
 {
   return Glib::PropertyProxy<bool>(this, "size-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_size_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "size-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_size_points() 
 {
   return Glib::PropertyProxy<double>(this, "size-points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_size_points() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "size-points");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_strikethrough() 
 {
   return Glib::PropertyProxy<bool>(this, "strikethrough");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_strikethrough() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_strikethrough_set() 
 {
   return Glib::PropertyProxy<bool>(this, "strikethrough-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_strikethrough_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "strikethrough-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Pango::Underline> Text::property_underline() 
 {
   return Glib::PropertyProxy<Pango::Underline>(this, "underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Pango::Underline> Text::property_underline() const
 {
   return Glib::PropertyProxy_ReadOnly<Pango::Underline>(this, "underline");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_underline_set() 
 {
   return Glib::PropertyProxy<bool>(this, "underline-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_underline_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "underline-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<int> Text::property_rise() 
 {
   return Glib::PropertyProxy<int>(this, "rise");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<int> Text::property_rise() const
 {
   return Glib::PropertyProxy_ReadOnly<int>(this, "rise");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_rise_set() 
 {
   return Glib::PropertyProxy<bool>(this, "rise-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_rise_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "rise-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_scale() 
 {
   return Glib::PropertyProxy<double>(this, "scale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_scale() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "scale");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_scale_set() 
 {
   return Glib::PropertyProxy<bool>(this, "scale-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_scale_set() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "scale-set");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::AnchorType> Text::property_anchor() 
 {
   return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> Text::property_anchor() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Justification> Text::property_justification() 
 {
   return Glib::PropertyProxy<Gtk::Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Justification> Text::property_justification() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Justification>(this, "justification");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_clip_width() 
 {
   return Glib::PropertyProxy<double>(this, "clip-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_clip_width() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "clip-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_clip_height() 
 {
   return Glib::PropertyProxy<double>(this, "clip-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_clip_height() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "clip-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Text::property_clip() 
 {
   return Glib::PropertyProxy<bool>(this, "clip");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Text::property_clip() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "clip");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_x_offset() 
 {
   return Glib::PropertyProxy<double>(this, "x-offset");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_x_offset() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x-offset");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_y_offset() 
 {
   return Glib::PropertyProxy<double>(this, "y-offset");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_y_offset() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y-offset");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Glib::ustring> Text::property_fill_color() 
 {
   return Glib::PropertyProxy<Glib::ustring>(this, "fill-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Glib::ustring> Text::property_fill_color() const
 {
   return Glib::PropertyProxy_ReadOnly<Glib::ustring>(this, "fill-color");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gdk::Color> Text::property_fill_color_gdk() 
 {
   return Glib::PropertyProxy<Gdk::Color>(this, "fill-color-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gdk::Color> Text::property_fill_color_gdk() const
 {
   return Glib::PropertyProxy_ReadOnly<Gdk::Color>(this, "fill-color-gdk");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<guint> Text::property_fill_color_rgba() 
 {
   return Glib::PropertyProxy<guint>(this, "fill-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<guint> Text::property_fill_color_rgba() const
 {
   return Glib::PropertyProxy_ReadOnly<guint>(this, "fill-color-rgba");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> > Text::property_fill_stipple() 
 {
   return Glib::PropertyProxy< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > Text::property_fill_stipple() const
 {
   return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> >(this, "fill-stipple");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_text_width() 
 {
   return Glib::PropertyProxy<double>(this, "text-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_text_width() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "text-width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Text::property_text_height() 
 {
   return Glib::PropertyProxy<double>(this, "text-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Text::property_text_height() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "text-height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/text.h b/libs/libgnomecanvasmm/libgnomecanvasmm/text.h
index 311c631e07..d73285c5af 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/text.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/text.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_TEXT_H
 #define _LIBGNOMECANVASMM_TEXT_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -101,13 +100,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -118,48 +113,46 @@ public:
   Text(Group& parent, double x, double y, const Glib::ustring& text);
   explicit Text(Group& parent);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text to render.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text to render.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Marked up text to render.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-
-  #ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -167,19 +160,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_x() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -187,99 +176,79 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_y() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a string.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a string.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a PangoFontDescription struct.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font description as a PangoFontDescription struct.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of the font 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<Glib::ustring> property_family() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Name of the font 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_family_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_family_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -287,399 +256,319 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Pango::AttrList> property_attributes() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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<Pango::Style> property_style() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_style_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_style_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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<Pango::Variant> property_variant() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_variant_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_variant_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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<int> property_weight() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_weight_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_weight_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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<Pango::Weight> property_stretch() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_stretch_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_stretch_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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<int> property_size() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_size_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the font 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<bool> property_size_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font size in 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<double> property_size_points() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Font size in 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to strike through the 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<bool> property_strikethrough() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether to strike through the 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<bool> property_strikethrough() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects 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<bool> property_strikethrough_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects 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_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Style of underline for this 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<Pango::Underline> property_underline() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Style of underline for this 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<Pango::Underline> property_underline() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects underlining.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects underlining.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Offset of text above the baseline (below the baseline if rise is negative).
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Offset of text above the baseline (below the baseline if rise is negative).
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the 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<bool> property_rise_set() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects the 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<bool> property_rise_set() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Size of 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<double> property_scale() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Size of 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<double> property_scale() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects font scaling.
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Whether this tag affects font scaling.
+/** 
    *
    * 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -687,19 +576,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> property_anchor() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -707,19 +592,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Justification> property_justification() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -727,19 +608,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_clip_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -747,19 +624,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_clip_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -767,19 +640,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_clip() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -787,19 +656,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_x_offset() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -807,79 +672,63 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_y_offset() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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<Glib::ustring> property_fill_color() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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<Gdk::Color> property_fill_color_gdk() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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<Gdk::Color> property_fill_color_gdk() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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<guint> property_fill_color_rgba() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Text 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<guint> property_fill_color_rgba() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -887,47 +736,38 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Bitmap> > property_fill_stipple() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the rendered 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<double> property_text_width() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Width of the rendered 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<double> property_text_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** Height of the rendered 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<double> property_text_height() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
-/** Height of the rendered 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<double> property_text_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -935,7 +775,6 @@ public:
 } /* namespace Canvas */
 } /* namespace Gnome */
 
-
 namespace Glib
 {
   /** @relates Gnome::Canvas::Text
@@ -944,8 +783,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Text* wrap(GnomeCanvasText* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_TEXT_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/widget.cc b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.cc
index 4d02f0947e..ab9709f629 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/widget.cc
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.cc
@@ -1,6 +1,5 @@
 // Generated by gtkmmproc -- DO NOT MODIFY!
 
-
 #include <libgnomecanvasmm/widget.h>
 #include <libgnomecanvasmm/private/widget_p.h>
 
@@ -51,6 +50,7 @@ Widget::Widget(Group& parentx)
 } /* namespace Canvas */
 } /* namespace Gnome */
 
+
 namespace
 {
 } // anonymous namespace
@@ -100,13 +100,8 @@ 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);
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 }
 
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
-
 
 Glib::ObjectBase* Widget_Class::wrap_new(GObject* o)
 {
@@ -147,107 +142,75 @@ GType Widget::get_base_type()
 }
 
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::Widget*> Widget::property_widget() 
 {
   return Glib::PropertyProxy<Gtk::Widget*>(this, "widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::Widget*> Widget::property_widget() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::Widget*>(this, "widget");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Widget::property_x() 
 {
   return Glib::PropertyProxy<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Widget::property_x() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "x");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Widget::property_y() 
 {
   return Glib::PropertyProxy<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Widget::property_y() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "y");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Widget::property_width() 
 {
   return Glib::PropertyProxy<double>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Widget::property_width() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "width");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<double> Widget::property_height() 
 {
   return Glib::PropertyProxy<double>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<double> Widget::property_height() const
 {
   return Glib::PropertyProxy_ReadOnly<double>(this, "height");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<Gtk::AnchorType> Widget::property_anchor() 
 {
   return Glib::PropertyProxy<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> Widget::property_anchor() const
 {
   return Glib::PropertyProxy_ReadOnly<Gtk::AnchorType>(this, "anchor");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy<bool> Widget::property_size_pixels() 
 {
   return Glib::PropertyProxy<bool>(this, "size-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 Glib::PropertyProxy_ReadOnly<bool> Widget::property_size_pixels() const
 {
   return Glib::PropertyProxy_ReadOnly<bool>(this, "size-pixels");
 }
-#endif //GLIBMM_PROPERTIES_ENABLED
-
-
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 
 } // namespace Canvas
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmm/widget.h b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.h
index 271e7e5b9f..0a087f23b3 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmm/widget.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmm/widget.h
@@ -3,7 +3,6 @@
 #ifndef _LIBGNOMECANVASMM_WIDGET_H
 #define _LIBGNOMECANVASMM_WIDGET_H
 
-
 #include <glibmm.h>
 
 /* $Id$ */
@@ -100,13 +99,9 @@ public:
 
 public:
   //C++ methods used to invoke GTK+ virtual functions:
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
 protected:
   //GTK+ Virtual Functions (override these to change behaviour):
-#ifdef GLIBMM_VFUNCS_ENABLED
-#endif //GLIBMM_VFUNCS_ENABLED
 
   //Default Signal Handlers::
 
@@ -117,17 +112,14 @@ public:
   Widget(Group& parent, double x, double y, Gtk::Widget& w);
   explicit Widget(Group& parent);
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -135,19 +127,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::Widget*> property_widget() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -155,19 +143,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_x() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -175,19 +159,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_y() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -195,19 +175,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_width() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -215,19 +191,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<double> property_height() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -235,19 +207,15 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<Gtk::AnchorType> property_anchor() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-  #ifdef GLIBMM_PROPERTIES_ENABLED
-/** 
+  /** 
    *
    * 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() ;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
-#ifdef GLIBMM_PROPERTIES_ENABLED
 /** 
    *
    * You rarely need to use properties because there are get_ and set_ methods for almost all of them.
@@ -255,7 +223,6 @@ public:
    * the value of the property changes.
    */
   Glib::PropertyProxy_ReadOnly<bool> property_size_pixels() const;
-#endif //#GLIBMM_PROPERTIES_ENABLED
 
 
 };
@@ -272,8 +239,6 @@ namespace Glib
    * @result A C++ instance that wraps this C instance.
    */
   Gnome::Canvas::Widget* wrap(GnomeCanvasWidget* object, bool take_copy = false);
-} //namespace Glib
-
-
+}
 #endif /* _LIBGNOMECANVASMM_WIDGET_H */
 
diff --git a/libs/libgnomecanvasmm/libgnomecanvasmmconfig.h b/libs/libgnomecanvasmm/libgnomecanvasmmconfig.h
index ff303303a5..a1d3378c29 100644
--- a/libs/libgnomecanvasmm/libgnomecanvasmmconfig.h
+++ b/libs/libgnomecanvasmm/libgnomecanvasmmconfig.h
@@ -5,7 +5,7 @@
 
 /* version numbers */
 #define LIBGNOMEUIMM_MAJOR_VERSION 2
-#define LIBGNOMEUIMM_MINOR_VERSION 16
+#define LIBGNOMEUIMM_MINOR_VERSION 10
 #define LIBGNOMEUIMM_MICRO_VERSION 0
 
 #endif /* _LIBGNOMEUIMM_CONFIG_H */
diff --git a/libs/midi++2/SConscript b/libs/midi++2/SConscript
index bc2c50cb2c..e9fbc0abf5 100644
--- a/libs/midi++2/SConscript
+++ b/libs/midi++2/SConscript
@@ -29,18 +29,24 @@ version.cc
 """)
 
 sysdep_sources = Split ("""
+jack_midiport.cc
 alsa_sequencer_midiport.cc
 coremidi_midiport.cc
 """)
 
-if env['SYSMIDI'] == 'CoreMIDI':
+if env['SYSMIDI'] == 'JACK MIDI':
+   sysdep_src = [ 'jack_midiport.cc' ]
+   midi2.Append (CCFLAGS="-DWITH_JACK_MIDI")
+elif env['SYSMIDI'] == 'ALSA Sequencer':
+   sysdep_src = [ 'alsa_sequencer_midiport.cc' ]
+   midi2.Append (CCFLAGS="-DWITH_ALSA")
+elif env['SYSMIDI'] == 'CoreMIDI':
    sysdep_src = [ 'coremidi_midiport.cc' ]
    midi2.Append (CCFLAGS="-DWITH_COREMIDI")
    midi2.Append (LINKFLAGS="-framework CoreMIDI")
    midi2.Append (LINKFLAGS="-framework CoreFoundation")
-else:
-   sysdep_src = [ 'alsa_sequencer_midiport.cc' ]
-   midi2.Append (CCFLAGS="-DWITH_ALSA")
+
+
 
 midi2.Append(CCFLAGS="-D_REENTRANT -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE")
 midi2.Append(CCFLAGS="-DLIBSIGC_DISABLE_DEPRECATED")
diff --git a/libs/midi++2/alsa_sequencer_midiport.cc b/libs/midi++2/alsa_sequencer_midiport.cc
index a47678bf1b..bf891108c6 100644
--- a/libs/midi++2/alsa_sequencer_midiport.cc
+++ b/libs/midi++2/alsa_sequencer_midiport.cc
@@ -94,8 +94,7 @@ ALSA_SequencerMidiPort::selectable () const
 	return -1;
 }
 
-int 
-ALSA_SequencerMidiPort::write (byte *msg, size_t msglen)	
+int ALSA_SequencerMidiPort::write (byte *msg, size_t msglen, timestamp_t timestamp)	
 {
 	TR_FN ();
 	int R;
@@ -134,8 +133,7 @@ ALSA_SequencerMidiPort::write (byte *msg, size_t msglen)
 	return totwritten;
 }
 
-int 
-ALSA_SequencerMidiPort::read (byte *buf, size_t max)
+int ALSA_SequencerMidiPort::read (byte *buf, size_t max, timestamp_t timestamp)
 {
 	TR_FN();
 	int err;
diff --git a/libs/midi++2/coremidi_midiport.cc b/libs/midi++2/coremidi_midiport.cc
index 8d1d927b7b..2cd98239ec 100644
--- a/libs/midi++2/coremidi_midiport.cc
+++ b/libs/midi++2/coremidi_midiport.cc
@@ -56,7 +56,7 @@ void CoreMidi_MidiPort::Close ()
 	if (midi_client) MIDIClientDispose(midi_client);
 }
 
-int CoreMidi_MidiPort::write (byte *msg, size_t msglen)	
+int CoreMidi_MidiPort::write (byte *msg, size_t msglen, timestamp_t timestamp)	
 {
 	OSStatus err;
     MIDIPacketList* pktlist = (MIDIPacketList*)midi_buffer;
diff --git a/libs/midi++2/fd_midiport.cc b/libs/midi++2/fd_midiport.cc
index 1d21642a00..81d81c8558 100644
--- a/libs/midi++2/fd_midiport.cc
+++ b/libs/midi++2/fd_midiport.cc
@@ -152,7 +152,7 @@ FD_MidiPort::do_slow_write (byte *msg, unsigned int msglen)
 }
 
 int
-FD_MidiPort::read (byte* buf, size_t max)
+FD_MidiPort::read (byte* buf, size_t max, timestamp_t timestamp)
 {
 	int nread;
 	
diff --git a/libs/midi++2/jack_midiport.cc b/libs/midi++2/jack_midiport.cc
new file mode 100644
index 0000000000..4b2808a698
--- /dev/null
+++ b/libs/midi++2/jack_midiport.cc
@@ -0,0 +1,126 @@
+/*
+  Copyright (C) 2006 Paul Davis 
+  Written by Dave Robillard
+ 
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+ 
+  This program 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 General Public License for more details.
+ 
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <fcntl.h>
+#include <cerrno>
+#include <cassert>
+
+#include <midi++/types.h>
+#include <midi++/jack.h>
+#include <midi++/port_request.h>
+
+using namespace std;
+using namespace MIDI;
+
+JACK_MidiPort::JACK_MidiPort(PortRequest & req, jack_client_t* jack_client)
+	: Port(req)
+	, _jack_client(jack_client)
+	, _jack_input_port(NULL)
+	, _jack_output_port(NULL)
+	, _last_read_index(0)
+{
+	int err = create_ports(req);
+
+	if (!err) {
+		req.status = PortRequest::OK;
+		_ok = true;
+	} else {
+		req.status = PortRequest::Unknown;
+	}
+}
+
+JACK_MidiPort::~JACK_MidiPort()
+{
+	// FIXME: remove port
+}
+
+void
+JACK_MidiPort::cycle_start (nframes_t nframes)
+{
+	Port::cycle_start(nframes);
+	assert(_nframes_this_cycle == nframes);
+	_last_read_index = 0;
+	jack_midi_clear_buffer(jack_port_get_buffer(_jack_output_port, nframes));
+}
+
+int
+JACK_MidiPort::write(byte * msg, size_t msglen, timestamp_t timestamp)
+{
+	assert(_currently_in_cycle);
+	assert(timestamp < _nframes_this_cycle);
+	assert(_jack_output_port);
+
+	// FIXME: return value correct?
+	return jack_midi_event_write (
+		jack_port_get_buffer(_jack_output_port, _nframes_this_cycle),
+		timestamp, msg, msglen);
+}
+
+int
+JACK_MidiPort::read(byte * buf, size_t max, timestamp_t timestamp)
+{
+	assert(_currently_in_cycle);
+	assert(timestamp < _nframes_this_cycle);
+	assert(_jack_input_port);
+
+	jack_midi_event_t ev;
+
+	int err = jack_midi_event_get (&ev,
+		jack_port_get_buffer(_jack_input_port, _nframes_this_cycle),
+		_last_read_index++);
+	
+	if (!err) {
+		memcpy(buf, ev.buffer, ev.size);
+		return ev.size;
+	} else {
+		return 0;
+	}
+}
+
+int
+JACK_MidiPort::create_ports(PortRequest & req)
+{
+	assert(!_jack_input_port);
+	assert(!_jack_output_port);
+	
+	jack_nframes_t nframes = jack_get_buffer_size(_jack_client);
+
+	bool ret = true;
+
+	if (req.mode == O_RDWR || req.mode == O_WRONLY) {
+		_jack_output_port = jack_port_register(_jack_client,
+			string(req.tagname).append("_out").c_str(),
+			JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
+  		jack_midi_clear_buffer(
+			jack_port_get_buffer(_jack_output_port, nframes));
+		ret = ret && (_jack_output_port != NULL);
+	}
+
+	if (req.mode == O_RDWR || req.mode == O_RDONLY) {
+		_jack_input_port = jack_port_register(_jack_client,
+			string(req.tagname).append("_in").c_str(),
+			JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
+  		jack_midi_clear_buffer(
+			jack_port_get_buffer(_jack_input_port, nframes));
+		ret = ret && (_jack_input_port != NULL);
+	}
+
+	return ret ? 0 : -1;
+}
+
diff --git a/libs/midi++2/midi++/alsa_rawmidi.h b/libs/midi++2/midi++/alsa_rawmidi.h
index d2aa6f5181..8e50609fbe 100644
--- a/libs/midi++2/midi++/alsa_rawmidi.h
+++ b/libs/midi++2/midi++/alsa_rawmidi.h
@@ -28,6 +28,8 @@
 #include <midi++/port.h>
 #include <midi++/fd_midiport.h>
 
+namespace MIDI {
+
 class ALSA_RawMidiPort : public MIDI::FD_MidiPort
 
 {
@@ -37,6 +39,7 @@ class ALSA_RawMidiPort : public MIDI::FD_MidiPort
 	virtual ~ALSA_RawMidiPort () {}
 };
 
+} // namespace MIDI
 
 #endif // __alsa_rawmidi_h__
 
diff --git a/libs/midi++2/midi++/alsa_sequencer.h b/libs/midi++2/midi++/alsa_sequencer.h
index 5ca70529c5..7fe880fe63 100644
--- a/libs/midi++2/midi++/alsa_sequencer.h
+++ b/libs/midi++2/midi++/alsa_sequencer.h
@@ -43,9 +43,8 @@ class ALSA_SequencerMidiPort : public Port
 
   protected:
 	/* Direct I/O */
-	
-	int write (byte *msg, size_t msglen);	
-	int read (byte *buf, size_t max);
+	int write (byte *msg, size_t msglen, timestamp_t timestamp);	
+	int read (byte *buf, size_t max, timestamp_t timestamp);
 
   private:
 	snd_midi_event_t *decoder, *encoder;
diff --git a/libs/midi++2/midi++/channel.h b/libs/midi++2/midi++/channel.h
index 45da7db9f2..5a4a397b9d 100644
--- a/libs/midi++2/midi++/channel.h
+++ b/libs/midi++2/midi++/channel.h
@@ -31,17 +31,22 @@ namespace MIDI {
 
 class Port;
 
+/** Stateful MIDI channel class.
+ *
+ * This remembers various useful information about the current 'state' of a
+ * MIDI channel (eg current pitch bend value).
+ */
 class Channel : public sigc::trackable {
 
   public:
 	Channel (byte channel_number, Port &);
 
-	Port &midi_port()               { return port; }
-	byte channel()                  { return channel_number; }
-	byte program()                  { return program_number; }
-	byte bank()                     { return bank_number; }
-	byte pressure ()                { return chanpress; }
-	byte poly_pressure (byte n)     { return polypress[n]; }
+	Port &midi_port()               { return _port; }
+	byte channel()                  { return _channel_number; }
+	byte program()                  { return _program_number; }
+	byte bank()                     { return _bank_number; }
+	byte pressure ()                { return _chanpress; }
+	byte poly_pressure (byte n)     { return _polypress[n]; }
 
 	byte last_note_on () { 
 		return _last_note_on;
@@ -57,53 +62,52 @@ class Channel : public sigc::trackable {
 	}
 
 	pitchbend_t pitchbend () { 
-		return pitch_bend;
+		return _pitch_bend;
 	}
 
 	controller_value_t controller_value (byte n) { 
-		return controller_val[n%128];
+		return _controller_val[n%128];
 	}
 
 	controller_value_t *controller_addr (byte n) {
-		return &controller_val[n%128];
+		return &_controller_val[n%128];
 	}
 
 	void set_controller (byte n, byte val) {
-		controller_val[n%128] = val;
+		_controller_val[n%128] = val;
 	}
 
-	int channel_msg (byte id, byte val1, byte val2);
-
-	int all_notes_off () {
-		return channel_msg (MIDI::controller, 123, 0);
+	bool channel_msg (byte id, byte val1, byte val2, timestamp_t timestamp);
+	bool all_notes_off (timestamp_t timestamp) {
+		return channel_msg (MIDI::controller, 123, 0, timestamp);
 	}
 	
-	int control (byte id, byte value) {
-		return channel_msg (MIDI::controller, id, value);
+	bool control (byte id, byte value, timestamp_t timestamp) {
+		return channel_msg (MIDI::controller, id, value, timestamp);
 	}
 	
-	int note_on (byte note, byte velocity) {
-		return channel_msg (MIDI::on, note, velocity);
+	bool note_on (byte note, byte velocity, timestamp_t timestamp) {
+		return channel_msg (MIDI::on, note, velocity, timestamp);
 	}
 	
-	int note_off (byte note, byte velocity) {
-		return channel_msg (MIDI::off, note, velocity);
+	bool note_off (byte note, byte velocity, timestamp_t timestamp) {
+		return channel_msg (MIDI::off, note, velocity, timestamp);
 	}
 	
-	int aftertouch (byte value) {
-		return channel_msg (MIDI::chanpress, value, 0);
+	bool aftertouch (byte value, timestamp_t timestamp) {
+		return channel_msg (MIDI::chanpress, value, 0, timestamp);
 	}
 
-	int poly_aftertouch (byte note, byte value) {
-		return channel_msg (MIDI::polypress, note, value);
+	bool poly_aftertouch (byte note, byte value, timestamp_t timestamp) {
+		return channel_msg (MIDI::polypress, note, value, timestamp);
 	}
 
-	int program_change (byte value) {
-		return channel_msg (MIDI::program, value, 0);
+	bool program_change (byte value, timestamp_t timestamp) {
+		return channel_msg (MIDI::program, value, 0, timestamp);
 	}
 
-	int pitchbend (byte msb, byte lsb) {
-		return channel_msg (MIDI::pitchbend, lsb, msb);
+	bool pitchbend (byte msb, byte lsb, timestamp_t timestamp) {
+		return channel_msg (MIDI::pitchbend, lsb, msb, timestamp);
 	}
 
   protected:
@@ -112,34 +116,33 @@ class Channel : public sigc::trackable {
 	void connect_output_signals ();
 
   private:
-	Port &port;
+	Port & _port;
 
 	/* Current channel values */
-
-	byte     channel_number;
-        byte     bank_number;
-	byte     program_number;
-	byte     rpn_msb;
-	byte     rpn_lsb;
-	byte     nrpn_msb;
-	byte     nrpn_lsb;
-	byte     chanpress;
-	byte     polypress[128];
-	bool         controller_14bit[128];
-	controller_value_t  controller_val[128];
-	byte     controller_msb[128];
-	byte     controller_lsb[128];
-	byte     _last_note_on;
-	byte     _last_on_velocity;
-	byte     _last_note_off;
-	byte     _last_off_velocity;
-	pitchbend_t  pitch_bend;
-	bool         _omni;
-	bool         _poly;
-	bool         _mono;
-	size_t       _notes_on;
-
-	void reset (bool notes_off = true);
+	byte               _channel_number;
+	byte               _bank_number;
+	byte               _program_number;
+	byte               _rpn_msb;
+	byte               _rpn_lsb;
+	byte               _nrpn_msb;
+	byte               _nrpn_lsb;
+	byte               _chanpress;
+	byte               _polypress[128];
+	bool               _controller_14bit[128];
+	controller_value_t _controller_val[128];
+	byte               _controller_msb[128];
+	byte               _controller_lsb[128];
+	byte               _last_note_on;
+	byte               _last_on_velocity;
+	byte               _last_note_off;
+	byte               _last_off_velocity;
+	pitchbend_t        _pitch_bend;
+	bool               _omni;
+	bool               _poly;
+	bool               _mono;
+	size_t             _notes_on;
+
+	void reset (timestamp_t timestamp, nframes_t nframes, bool notes_off = true);
 	
 	void process_note_off (Parser &, EventTwoBytes *);
 	void process_note_on (Parser &, EventTwoBytes *);
diff --git a/libs/midi++2/midi++/coremidi_midiport.h b/libs/midi++2/midi++/coremidi_midiport.h
index d7df23aa04..30e07e01a5 100644
--- a/libs/midi++2/midi++/coremidi_midiport.h
+++ b/libs/midi++2/midi++/coremidi_midiport.h
@@ -32,35 +32,35 @@
 
 namespace MIDI {
 
-    class CoreMidi_MidiPort:public Port {
-      public:
-	CoreMidi_MidiPort(PortRequest & req);
-	virtual ~ CoreMidi_MidiPort();
+class CoreMidi_MidiPort:public Port {
+	public:
+		CoreMidi_MidiPort(PortRequest & req);
+		virtual ~ CoreMidi_MidiPort();
 
-	virtual int selectable() const {
-	    return -1;
-	}
-      protected:
-	/* Direct I/O */
-	int write(byte * msg, size_t msglen);
-	int read(byte * buf, size_t max) {
-	    return 0;
-	} /* CoreMidi callback */
-	    static void read_proc(const MIDIPacketList * pktlist,
-				  void *refCon, void *connRefCon);
+		virtual int selectable() const {
+			return -1;
+		}
+	protected:
+		/* Direct I/O */
+		int write (byte *msg, size_t msglen, timestamp_t timestamp);	
+		int read (byte *buf, size_t max, timestamp_t timestamp);
 
-      private:
-	byte midi_buffer[1024];
-	MIDIClientRef midi_client;
-	MIDIEndpointRef midi_destination;
-	MIDIEndpointRef midi_source;
+		/* CoreMidi callback */
+		static void read_proc(const MIDIPacketList * pktlist,
+				void *refCon, void *connRefCon);
 
-	int Open(PortRequest & req);
-	void Close();
-	static MIDITimeStamp MIDIGetCurrentHostTime();
+	private:
+		byte midi_buffer[1024];
+		MIDIClientRef midi_client;
+		MIDIEndpointRef midi_destination;
+		MIDIEndpointRef midi_source;
 
-	bool firstrecv;
-    };
+		int Open(PortRequest & req);
+		void Close();
+		static MIDITimeStamp MIDIGetCurrentHostTime();
+
+		bool firstrecv;
+};
 
 } // namespace MIDI
 
diff --git a/libs/midi++2/midi++/factory.h b/libs/midi++2/midi++/factory.h
index f2963624fe..df7f35e073 100644
--- a/libs/midi++2/midi++/factory.h
+++ b/libs/midi++2/midi++/factory.h
@@ -28,7 +28,7 @@ namespace MIDI {
 
 class PortFactory {
   public:
-	Port *create_port (PortRequest &req);
+	Port *create_port (PortRequest &req, void* data);
 
 	static bool ignore_duplicate_devices (Port::Type);
 };
diff --git a/libs/midi++2/midi++/fd_midiport.h b/libs/midi++2/midi++/fd_midiport.h
index d7fae400a0..8a1af55967 100644
--- a/libs/midi++2/midi++/fd_midiport.h
+++ b/libs/midi++2/midi++/fd_midiport.h
@@ -52,7 +52,10 @@ class FD_MidiPort : public Port
 	int _fd;
 	virtual void open (PortRequest &req);
 
-	virtual int write (byte *msg, size_t msglen) {
+	/* Direct I/O */
+	
+	virtual int write (byte *msg, size_t msglen,
+	                   timestamp_t timestamp) {
 		int nwritten;
 		
 		if ((_mode & O_ACCMODE) == O_RDONLY) {
@@ -79,7 +82,8 @@ class FD_MidiPort : public Port
 		return nwritten;
 	}
 
-	virtual int read (byte *buf, size_t max);
+	virtual int read (byte *buf, size_t max,
+	                  timestamp_t timestamp);
 
   private:
 	static std::string *midi_dirpath;
diff --git a/libs/midi++2/midi++/jack.h b/libs/midi++2/midi++/jack.h
new file mode 100644
index 0000000000..c20b2693f1
--- /dev/null
+++ b/libs/midi++2/midi++/jack.h
@@ -0,0 +1,68 @@
+/*
+    Copyright (C) 2006 Paul Davis 
+	Written by Dave Robillard
+ 
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+ 
+    This program 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 General Public License for more details.
+ 
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ 
+    $Id: jack.h 4 2005-05-13 20:47:18Z taybin $
+*/
+
+#ifndef __jack_midiport_h__
+#define __jack_midiport_h__
+
+#include <vector>
+#include <string>
+
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <jack/jack.h>
+#include <jack/midiport.h>
+#include <midi++/port.h>
+
+namespace MIDI
+{
+
+
+class JACK_MidiPort : public Port
+{
+public:
+	JACK_MidiPort (PortRequest &req, jack_client_t* jack_client);
+	virtual ~JACK_MidiPort ();
+
+	/* No select(2)/poll(2)-based I/O */
+	virtual int selectable() const { return -1; }
+	
+	virtual void cycle_start(nframes_t nframes);
+
+protected:
+	/* Direct I/O */
+	int write(byte *msg, size_t msglen, timestamp_t timestamp);
+	int read(byte *buf, size_t max, timestamp_t timestamp);
+
+private:
+	int create_ports(PortRequest &req);
+
+	jack_client_t* _jack_client;
+	jack_port_t*   _jack_input_port;
+	jack_port_t*   _jack_output_port;
+	nframes_t      _last_read_index;
+};
+
+
+} /* namespace MIDI */
+
+#endif // __jack_midiport_h__
+
diff --git a/libs/midi++2/midi++/manager.h b/libs/midi++2/midi++/manager.h
index 40140cfde2..80de408ee1 100644
--- a/libs/midi++2/midi++/manager.h
+++ b/libs/midi++2/midi++/manager.h
@@ -28,10 +28,27 @@
 
 namespace MIDI {
 
+/** Creates, stores, and manages system MIDI ports.
+ */
 class Manager {
   public:
 	~Manager ();
 	
+	void set_api_data(void* data) { api_data = data; }
+
+	/** Signal the start of an audio cycle.
+	 * This MUST be called before any reading/writing for this cycle.
+	 * Realtime safe.
+	 */
+	void cycle_start(nframes_t nframes);
+
+	/** Signal the end of an audio cycle.
+	 * This signifies that the cycle began with @ref cycle_start has ended.
+	 * This MUST be called at the end of each cycle.
+	 * Realtime safe.
+	 */
+	void cycle_end();
+
 	Port *add_port (PortRequest &);
 	int   remove_port (std::string port);
 
@@ -40,20 +57,6 @@ class Manager {
 
 	size_t    nports () { return ports_by_device.size(); }
 
-	/* defaults for clients who are not picky */
-	
-	Port *inputPort;
-	Port *outputPort;
-	channel_t inputChannelNumber;
-	channel_t outputChannelNumber;
-
-	int set_input_port (size_t port);
-	int set_input_port (std::string);
-	int set_output_port (size_t port);
-	int set_output_port (std::string);
-	int set_input_channel (channel_t);
-	int set_output_channel (channel_t);
-
 	int foreach_port (int (*func)(const Port &, size_t n, void *), 
 			  void *arg);
 
@@ -79,6 +82,8 @@ class Manager {
 	PortMap         ports_by_device; /* canonical */
 	PortMap         ports_by_tag;    /* may contain duplicate Ports */
 
+	void *api_data;
+
 	void close_ports ();
 };
 
diff --git a/libs/midi++2/midi++/nullmidi.h b/libs/midi++2/midi++/nullmidi.h
index 13591db4e6..1474da77ed 100644
--- a/libs/midi++2/midi++/nullmidi.h
+++ b/libs/midi++2/midi++/nullmidi.h
@@ -45,11 +45,12 @@ class Null_MidiPort : public Port
 
 	virtual ~Null_MidiPort () {};
 
-	virtual int write (byte *msg, size_t msglen) {
+	/* Direct I/O */
+	int write (byte *msg, size_t msglen, timestamp_t timestamp) {
 		return msglen;
 	}
 
-	virtual int read (byte *buf, size_t max) {
+	int read (byte *buf, size_t max, timestamp_t timestamp) {
 		return 0;
 	}
 	
diff --git a/libs/midi++2/midi++/port.h b/libs/midi++2/midi++/port.h
index 123ac9e3d8..e4338cf952 100644
--- a/libs/midi++2/midi++/port.h
+++ b/libs/midi++2/midi++/port.h
@@ -23,6 +23,7 @@
 
 #include <sigc++/sigc++.h>
 
+#include <pbd/selectable.h>
 #include <midi++/types.h>
 #include <midi++/parser.h>
 
@@ -35,6 +36,7 @@ class Port : public sigc::trackable {
   public:
 	enum Type {
 		Unknown,
+		JACK_Midi,
 		ALSA_RawMidi,
 		ALSA_Sequencer,
 		CoreMidi_MidiPort,
@@ -42,42 +44,64 @@ class Port : public sigc::trackable {
 		FIFO
 	};
 
-
 	Port (PortRequest &);
 	virtual ~Port ();
 
-	/* Direct I/O */
+	// FIXME: make Manager a friend of port so these can be hidden?
+	
+	/* Only for use by MidiManager.  Don't ever call this. */
+	virtual void cycle_start(nframes_t nframes);
 
-	virtual int write (byte *msg, size_t msglen) = 0;	
-	virtual int read (byte *buf, size_t max) = 0;
+	/* Only for use by MidiManager.  Don't ever call this. */
+	virtual void cycle_end();
 
-	/* slowdown i/o to a loop of single byte emissions
-	   interspersed with a busy loop of 10000 * this value.
+	/* Direct I/O */
+	
+	/** Read a message from port.
+	 * @param buf Raw MIDI message to send
+	 * @param max Max size to write to @a buf
+	 * @param timestamp Time stamp in frames of this message (relative to cycle start)
+	 * @return number of bytes successfully written to \a buf
+	 */
+	virtual int read(byte *buf, size_t max, timestamp_t timestamp) = 0;
+	
+	/** Write a message to port.
+	 * @param msg Raw MIDI message to send
+	 * @param msglen Size of @a msg
+	 * @param timestamp Time stamp in frames of this message (relative to cycle start)
+	 * @return number of bytes successfully written
+	 */
+	virtual int write(byte *msg, size_t msglen, timestamp_t timestamp) = 0;	
+
+	/** Write a message to port.
+	 * @return true on success.
+	 * FIXME: describe semantics here
+	 */
+	bool midimsg (byte *msg, size_t len, timestamp_t timestamp) {
+		return !(write (msg, len, timestamp) == (int) len);
+	}
 
-	   This may be ignored by a particular instance
-	   of this virtual class. See FD_MidiPort for an 
-	   example of where it used.  
-	*/
+	bool clock (timestamp_t timestamp);
 
+	/** Slow down I/O to a loop of single byte emissions
+	  * interspersed with a busy loop of 10000 * this value.
+	  *
+	  * This may be ignored by a particular instance of this virtual
+	  * class. See FD_MidiPort for an example of where it used. */
 	void set_slowdown (size_t n) { slowdown = n; }
 
 	/* select(2)/poll(2)-based I/O */
 
+	/** Get the file descriptor for port.
+	 * @return File descriptor, or -1 if not selectable. */
 	virtual int selectable() const = 0;
 
-	//void selector_read_callback (Select::Selectable *, Select::Condition);
-
-	static void xforms_read_callback (int cond, int fd, void *ptr);
-	static void gtk_read_callback (void *ptr, int fd, int cond);
-	
-	static void write_callback (byte *msg, unsigned int len, void *);
-	
 	Channel *channel (channel_t chn) { 
 		return _channel[chn&0x7F];
 	}
 	
-	Parser *input()     { return input_parser; }
-	Parser *output()    { return output_parser; }
+	Parser *input()  { return input_parser; }
+	Parser *output() { return output_parser; }
 
 	void iostat (int *written, int *read, 
 		     const size_t **in_counts,
@@ -97,43 +121,31 @@ class Port : public sigc::trackable {
 		}
 	}
 	
-	int midimsg (byte *msg, size_t len) {
-		return !(write (msg, len) == (int) len);
-	} 
-
-	int three_byte_msg (byte a, byte b, byte c) {
-		byte msg[3];
-
-            	msg[0] = a;
-		msg[1] = b;
-		msg[2] = c;
-
-		return !(write (msg, 3) == 3);
-	} 
-	
-	int clock ();
+	bool clock ();
 	
 	const char *device () const { return _devname.c_str(); }
-	const char *name () const   { return _tagname.c_str(); }
-	Type   type () const        { return _type; }
-	int    mode () const        { return _mode; }
-	bool   ok ()   const        { return _ok; }
-	size_t number () const      { return _number; }
+	const char *name ()   const { return _tagname.c_str(); }
+	Type        type ()   const { return _type; }
+	int         mode ()   const { return _mode; }
+	bool        ok ()     const { return _ok; }
+	size_t      number () const { return _number; }
 
   protected:
-	bool _ok;
-	Type _type;
-	std::string _devname;
-	std::string _tagname;
-	int _mode;
-	size_t _number;
-	Channel *_channel[16];
+	bool             _ok;
+	bool             _currently_in_cycle;
+	nframes_t        _nframes_this_cycle;
+	Type             _type;
+	std::string      _devname;
+	std::string      _tagname;
+	int              _mode;
+	size_t           _number;
+	Channel          *_channel[16];
 	sigc::connection thru_connection;
-	unsigned int bytes_written;
-	unsigned int bytes_read;
-	Parser *input_parser;
-	Parser *output_parser;
-	size_t slowdown;
+	unsigned int     bytes_written;
+	unsigned int     bytes_read;
+	Parser           *input_parser;
+	Parser           *output_parser;
+	size_t           slowdown;
 
   private:
 	static size_t nports;
diff --git a/libs/midi++2/midi++/types.h b/libs/midi++2/midi++/types.h
index 98855ca82d..a7929e16f5 100644
--- a/libs/midi++2/midi++/types.h
+++ b/libs/midi++2/midi++/types.h
@@ -20,12 +20,16 @@
 #ifndef __midi_types_h__
 #define __midi_types_h__
 
+#include <inttypes.h>
+
 namespace MIDI {
 
 	typedef char           channel_t;
-	typedef float controller_value_t;
+	typedef float          controller_value_t;
 	typedef unsigned char  byte;
 	typedef unsigned short pitchbend_t;
+	typedef uint32_t       nframes_t;
+	typedef uint32_t       timestamp_t;
 
 	enum eventType {
 	    none = 0x0,
diff --git a/libs/midi++2/midichannel.cc b/libs/midi++2/midichannel.cc
index a6759b7962..fe4f4afeb2 100644
--- a/libs/midi++2/midichannel.cc
+++ b/libs/midi++2/midichannel.cc
@@ -25,61 +25,61 @@
 using namespace sigc;
 using namespace MIDI;
 
-Channel::Channel (byte channelnum, Port &p) : port (p)
+Channel::Channel (byte channelnum, Port &p) : _port (p)
 {
-	channel_number = channelnum;
+	_channel_number = channelnum;
 
-	reset (false);
+	reset (0, 1, false);
 }	
 
 void
 Channel::connect_input_signals ()
 
 {
-	port.input()->channel_pressure[channel_number].connect
+	_port.input()->channel_pressure[_channel_number].connect
 		(mem_fun (*this, &Channel::process_chanpress));
-	port.input()->channel_note_on[channel_number].connect
+	_port.input()->channel_note_on[_channel_number].connect
 		(mem_fun (*this, &Channel::process_note_on));
-	port.input()->channel_note_off[channel_number].connect
+	_port.input()->channel_note_off[_channel_number].connect
 		(mem_fun (*this, &Channel::process_note_off));
-	port.input()->channel_poly_pressure[channel_number].connect
+	_port.input()->channel_poly_pressure[_channel_number].connect
 		(mem_fun (*this, &Channel::process_polypress));
-	port.input()->channel_program_change[channel_number].connect
+	_port.input()->channel_program_change[_channel_number].connect
 		(mem_fun (*this, &Channel::process_program_change));
-	port.input()->channel_controller[channel_number].connect
+	_port.input()->channel_controller[_channel_number].connect
 		(mem_fun (*this, &Channel::process_controller));
-	port.input()->channel_pitchbend[channel_number].connect
+	_port.input()->channel_pitchbend[_channel_number].connect
 		(mem_fun (*this, &Channel::process_pitchbend));
-	port.input()->reset.connect (mem_fun (*this, &Channel::process_reset));
+	_port.input()->reset.connect (mem_fun (*this, &Channel::process_reset));
 }
 
 void
 Channel::connect_output_signals ()
 
 {
-	port.output()->channel_pressure[channel_number].connect
+	_port.output()->channel_pressure[_channel_number].connect
 		(mem_fun (*this, &Channel::process_chanpress));
-	port.output()->channel_note_on[channel_number].connect
+	_port.output()->channel_note_on[_channel_number].connect
 		(mem_fun (*this, &Channel::process_note_on));
-	port.output()->channel_note_off[channel_number].connect
+	_port.output()->channel_note_off[_channel_number].connect
 		(mem_fun (*this, &Channel::process_note_off));
-	port.output()->channel_poly_pressure[channel_number].connect
+	_port.output()->channel_poly_pressure[_channel_number].connect
 		(mem_fun (*this, &Channel::process_polypress));
-	port.output()->channel_program_change[channel_number].connect
+	_port.output()->channel_program_change[_channel_number].connect
 		(mem_fun (*this, &Channel::process_program_change));
-	port.output()->channel_controller[channel_number].connect
+	_port.output()->channel_controller[_channel_number].connect
 		(mem_fun (*this, &Channel::process_controller));
-	port.output()->channel_pitchbend[channel_number].connect
+	_port.output()->channel_pitchbend[_channel_number].connect
 		(mem_fun (*this, &Channel::process_pitchbend));
-	port.output()->reset.connect (mem_fun (*this, &Channel::process_reset));
+	_port.output()->reset.connect (mem_fun (*this, &Channel::process_reset));
 }
 
 void
-Channel::reset (bool notes_off)
+Channel::reset (timestamp_t timestamp, nframes_t nframes, bool notes_off)
 {
-	program_number = channel_number;
-	bank_number = 0;
-	pitch_bend = 0;
+	_program_number = _channel_number;
+	_bank_number = 0;
+	_pitch_bend = 0;
 
 	_last_note_on = 0;
 	_last_note_off = 0;
@@ -87,25 +87,25 @@ Channel::reset (bool notes_off)
 	_last_off_velocity = 0;
 
 	if (notes_off) {
-		all_notes_off ();
+		all_notes_off (timestamp);
 	}
 
-	memset (polypress, 0, sizeof (polypress));
-	memset (controller_msb, 0, sizeof (controller_msb));
-	memset (controller_lsb, 0, sizeof (controller_lsb));
+	memset (_polypress, 0, sizeof (_polypress));
+	memset (_controller_msb, 0, sizeof (_controller_msb));
+	memset (_controller_lsb, 0, sizeof (_controller_lsb));
        
 	/* zero all controllers XXX not necessarily the right thing */
 
-	memset (controller_val, 0, sizeof (controller_val));
+	memset (_controller_val, 0, sizeof (_controller_val));
 
 	for (int n = 0; n < 128; n++) {
-		controller_14bit[n] = false;
+		_controller_14bit[n] = false;
 	}
 
-	rpn_msb = 0;
-	rpn_lsb = 0;
-	nrpn_msb = 0;
-	nrpn_lsb = 0;
+	_rpn_msb = 0;
+	_rpn_lsb = 0;
+	_nrpn_msb = 0;
+	_nrpn_lsb = 0;
 
 	_omni = true;
 	_poly = false;
@@ -155,20 +155,20 @@ Channel::process_controller (Parser &parser, EventTwoBytes *tb)
 		   it directly.
 		*/
 
-		cv = (unsigned short) controller_val[tb->controller_number];
+		cv = (unsigned short) _controller_val[tb->controller_number];
 
-		if (controller_14bit[tb->controller_number]) {
+		if (_controller_14bit[tb->controller_number]) {
 			cv = ((tb->value << 7) | (cv & 0x7f));
 		} else {
 			cv = tb->value;
 		}
 
-		controller_val[tb->controller_number] = (controller_value_t)cv;
+		_controller_val[tb->controller_number] = (controller_value_t)cv;
 
 	} else if ((tb->controller_number >= 32 && 
 		    tb->controller_number <= 63)) {
 		   
-		cv = (unsigned short) controller_val[tb->controller_number];
+		cv = (unsigned short) _controller_val[tb->controller_number];
 
 		/* LSB for CC 0-31 arrived. 
 
@@ -183,20 +183,20 @@ Channel::process_controller (Parser &parser, EventTwoBytes *tb)
 
 		int cn = tb->controller_number - 32;
 		   
-		if (controller_14bit[cn] == false) {
-			controller_14bit[cn] = true;
+		if (_controller_14bit[cn] == false) {
+			_controller_14bit[cn] = true;
 			cv = (cv << 7) | (tb->value & 0x7f);
 		} else {
 			cv = (cv & 0x3f80) | (tb->value & 0x7f);
 		}
 
-		controller_val[tb->controller_number] = 
+		_controller_val[tb->controller_number] = 
 			(controller_value_t) cv;
 	} else {
 
 		/* controller can only take 7 bit values */
 		
-		controller_val[tb->controller_number] = 
+		_controller_val[tb->controller_number] = 
 			(controller_value_t) tb->value;
 	}
 
@@ -204,11 +204,11 @@ Channel::process_controller (Parser &parser, EventTwoBytes *tb)
 	 */
 
 	if (tb->controller_number == 0) {
-		bank_number = (unsigned short) controller_val[0];
-		if (port.input()) {
-			port.input()->bank_change (*port.input(), bank_number);
-			port.input()->channel_bank_change[channel_number] 
-				(*port.input(), bank_number);
+		_bank_number = (unsigned short) _controller_val[0];
+		if (_port.input()) {
+			_port.input()->bank_change (*_port.input(), _bank_number);
+			_port.input()->channel_bank_change[_channel_number] 
+				(*_port.input(), _bank_number);
 		}
 	}
 
@@ -218,45 +218,47 @@ void
 Channel::process_program_change (Parser &parser, byte val) 
 
 {
-	program_number = val;
+	_program_number = val;
 }
 
 void
 Channel::process_chanpress (Parser &parser, byte val) 
 
 {
-	chanpress = val;
+	_chanpress = val;
 }
 
 void
 Channel::process_polypress (Parser &parser, EventTwoBytes *tb) 
 
 {
-	polypress[tb->note_number] = tb->value;
+	_polypress[tb->note_number] = tb->value;
 }
 
 void
 Channel::process_pitchbend (Parser &parser, pitchbend_t val) 
 
 {
-	pitch_bend = val;
+	_pitch_bend = val;
 }
 
 void
 Channel::process_reset (Parser &parser) 
 
 {
-	reset ();
+	reset (0, 1);
 }
 
-int
-Channel::channel_msg (byte id, byte val1, byte val2)
-
+/** Write a message to a channel.
+ * \return true if success
+ */
+bool
+Channel::channel_msg (byte id, byte val1, byte val2, timestamp_t timestamp)
 {
 	unsigned char msg[3];
 	int len = 0;
 
-	msg[0] = id | (channel_number & 0xf);
+	msg[0] = id | (_channel_number & 0xf);
 
 	switch (id) {
 	case off:
@@ -300,5 +302,5 @@ Channel::channel_msg (byte id, byte val1, byte val2)
 		break;
 	}
 
-	return port.midimsg (msg, len);
+	return _port.midimsg (msg, len, timestamp);
 }
diff --git a/libs/midi++2/midifactory.cc b/libs/midi++2/midifactory.cc
index 0a86c94cb9..de4a246bcf 100644
--- a/libs/midi++2/midifactory.cc
+++ b/libs/midi++2/midifactory.cc
@@ -17,11 +17,16 @@
     $Id$
 */
 
+#include <cassert>
 #include <midi++/types.h>
 #include <midi++/factory.h>
 #include <midi++/nullmidi.h>
 #include <midi++/fifomidi.h>
 
+#ifdef WITH_JACK_MIDI
+#include <midi++/jack.h>
+#endif // WITH_JACK_MIDI
+
 #ifdef WITH_ALSA
 #include <midi++/alsa_sequencer.h>
 #include <midi++/alsa_rawmidi.h>
@@ -35,13 +40,21 @@
 using namespace std;
 using namespace MIDI;
 
+// FIXME: void* data pointer, filthy
 Port *
-PortFactory::create_port (PortRequest &req)
+PortFactory::create_port (PortRequest &req, void* data)
 
 {
 	Port *port;
 	
 	switch (req.type) {
+#ifdef WITH_JACK_MIDI
+	case Port::JACK_Midi:
+		assert(data != NULL);
+		port = new JACK_MidiPort (req, (jack_client_t*)data);
+		break;
+#endif // WITH_JACK_MIDI
+	
 #ifdef WITH_ALSA
 	case Port::ALSA_RawMidi:
 		port = new ALSA_RawMidiPort (req);
diff --git a/libs/midi++2/midimanager.cc b/libs/midi++2/midimanager.cc
index 44fd89108c..970674232d 100644
--- a/libs/midi++2/midimanager.cc
+++ b/libs/midi++2/midimanager.cc
@@ -33,17 +33,11 @@ using namespace std;
 using namespace MIDI;
 using namespace PBD;
 
-/* XXX check for strdup leaks */
-
 Manager *Manager::theManager = 0;
 
 Manager::Manager () 
-      
+	: api_data(NULL)
 {
-	inputPort = 0;
-	outputPort = 0;
-	inputChannelNumber = 0;
-	outputChannelNumber = 0;
 }
 
 Manager::~Manager ()
@@ -109,8 +103,7 @@ Manager::add_port (PortRequest &req)
 			/* modes must be different or complementary */
 		}
 	}
-	
-	port = factory.create_port (req);
+	port = factory.create_port (req, api_data);
 	
 	if (port == 0) {
 		return 0;
@@ -129,18 +122,6 @@ Manager::add_port (PortRequest &req)
 	newpair.second = port;
 	ports_by_device.insert (newpair);
 
-	/* first port added becomes the default input
-	   port.
-	*/
-
-	if (inputPort == 0) {
-		inputPort = port;
-	} 
-
-	if (outputPort == 0) {
-		outputPort = port;
-	}
-
 	return port;
 }
 
@@ -161,92 +142,6 @@ Manager::remove_port (string name)
 	return 0;
 }
 
-int
-Manager::set_input_port (string tag)
-{
-	PortMap::iterator res;
-	bool found = false;
-
-	for (res = ports_by_tag.begin(); res != ports_by_tag.end(); res++) {
-		if (tag == (*res).first) {
-			found = true;
-			break;
-		}
-	}
-	
-	if (!found) {
-		return -1;
-	}
-
-	inputPort = (*res).second;
-
-	return 0;
-}
-
-int
-Manager::set_input_port (size_t portnum)
-
-{
-	PortMap::iterator res;
-
-	for (res = ports_by_tag.begin(); res != ports_by_tag.end(); res++) {
-		if ((*res).second->number() == portnum) {
-			inputPort = (*res).second;
-			return 0;
-		}
-	}
-
-	return -1;
-}
-
-int
-Manager::set_output_port (string tag)
-
-{
-	PortMap::iterator res;
-	bool found = false;
-
-	for (res = ports_by_tag.begin(); res != ports_by_tag.end(); res++) {
-		if (tag == (*res).first) {
-			found = true;
-			break;
-		}
-	}
-	
-	if (!found) {
-		return -1;
-	}
-
-	// XXX send a signal to say we're about to change output ports
-
-	if (outputPort) {
-		for (channel_t chan = 0; chan < 16; chan++) {
-			outputPort->channel (chan)->all_notes_off ();
-		}
-	}
-	outputPort = (*res).second;
-
-	// XXX send a signal to say we've changed output ports
-
-	return 0;
-}
-
-int
-Manager::set_output_port (size_t portnum)
-
-{
-	PortMap::iterator res;
-
-	for (res = ports_by_tag.begin(); res != ports_by_tag.end(); res++) {
-		if ((*res).second->number() == portnum) {
-			outputPort = (*res).second;
-			return 0;
-		}
-	}
-
-	return -1;
-}
-
 Port *
 Manager::port (string name)
 {
@@ -367,7 +262,6 @@ Manager::parse_port_request (string str, Port::Type type)
 		}
 
 	} else {
-                // check when tagname is freed
 		req->tagname = g_path_get_basename (req->devname);
 		req->mode = O_RDWR;
 	}
@@ -380,3 +274,20 @@ Manager::parse_port_request (string str, Port::Type type)
 
 	return 0;
 }
+
+void
+Manager::cycle_start(nframes_t nframes)
+{
+	for (PortMap::iterator i = ports_by_device.begin(); 
+	            i != ports_by_device.end(); i++)
+		(*i).second->cycle_start(nframes);
+}
+
+void
+Manager::cycle_end()
+{
+	for (PortMap::iterator i = ports_by_device.begin(); 
+	            i != ports_by_device.end(); i++)
+		(*i).second->cycle_end();
+}
+
diff --git a/libs/midi++2/midiparser.cc b/libs/midi++2/midiparser.cc
index 782c3a8239..a1f6ce39b4 100644
--- a/libs/midi++2/midiparser.cc
+++ b/libs/midi++2/midiparser.cc
@@ -521,13 +521,9 @@ Parser::scanner (unsigned char inbyte)
 	return;
 }
 
-/*
- * realtime_msg(inbyte)
- *
- * Call the real-time function for the specified byte, immediately.
+/** Call the real-time function for the specified byte, immediately.
  * These can occur anywhere, so they don't change the state.
  */
-
 void
 Parser::realtime_msg(unsigned char inbyte)
 
@@ -563,12 +559,9 @@ Parser::realtime_msg(unsigned char inbyte)
 	any (*this, &inbyte, 1);
 }
 
-/*
- * channel_msg(inbyte)
- *
- * Interpret a Channel (voice or mode) Message status byte.
- */
 
+/** Interpret a Channel (voice or mode) Message status byte.
+ */
 void
 Parser::channel_msg(unsigned char inbyte)
 {
@@ -609,16 +602,12 @@ Parser::channel_msg(unsigned char inbyte)
 	}
 }
 
-/*
- * system_msg(inbyte)
- *
- * Initialize (and possibly emit) the signals for the
+/** Initialize (and possibly emit) the signals for the
  * specified byte.  Set the state that the state-machine
  * should go into.  If the signal is not emitted
  * immediately, it will be when the state machine gets to
  * the end of the MIDI message.
  */
-
 void
 Parser::system_msg (unsigned char inbyte)
 {
diff --git a/libs/midi++2/midiport.cc b/libs/midi++2/midiport.cc
index a42aac2984..7f31b909d3 100644
--- a/libs/midi++2/midiport.cc
+++ b/libs/midi++2/midiport.cc
@@ -26,13 +26,14 @@
 #include <midi++/channel.h>
 #include <midi++/port_request.h>
 
-//using namespace Select;
+using namespace Select;
 using namespace MIDI;
 
 size_t Port::nports = 0;
 
 Port::Port (PortRequest &req)
-
+	: _currently_in_cycle(false)
+	, _nframes_this_cycle(0)
 {
 	_ok = false;  /* derived class must set to true if constructor
 			 succeeds.
@@ -83,51 +84,32 @@ Port::~Port ()
 	}
 }
 
-int
-Port::clock ()
-	
+/** Send a clock tick message.
+ * \return true on success.
+ */
+bool
+Port::clock (timestamp_t timestamp)
 {
 	static byte clockmsg = 0xf8;
 	
 	if (_mode != O_RDONLY) {
-		return midimsg (&clockmsg, 1);
+		return midimsg (&clockmsg, 1, timestamp);
 	}
 	
-	return 0;
-}
-
-/*
-void
-Port::selector_read_callback (Selectable *s, Select::Condition cond) 
-
-{
-	byte buf[64];
-	read (buf, sizeof (buf));
-}
-*/
-
-void
-Port::xforms_read_callback (int cond, int fd, void *ptr) 
-
-{
-	byte buf[64];
-	
-	((Port *)ptr)->read (buf, sizeof (buf));
+	return false;
 }
 
 void
-Port::gtk_read_callback (void *ptr, int fd, int cond)
-
+Port::cycle_start (nframes_t nframes)
 {
-	byte buf[64];
-	
-	((Port *)ptr)->read (buf, sizeof (buf));
+	_currently_in_cycle = true;
+	_nframes_this_cycle = nframes;
 }
 
 void
-Port::write_callback (byte *msg, unsigned int len, void *ptr)
-	
+Port::cycle_end ()
 {
-	((Port *)ptr)->write (msg, len);
+	_currently_in_cycle = false;
+	_nframes_this_cycle = 0;
 }
 
diff --git a/libs/midi++2/port_request.cc b/libs/midi++2/port_request.cc
index d081bdb570..d209f02574 100644
--- a/libs/midi++2/port_request.cc
+++ b/libs/midi++2/port_request.cc
@@ -36,7 +36,7 @@ PortRequest::PortRequest (const string &xdev,
 	
 	devname = strdup (xdev.c_str());
 	tagname = strdup (xtag.c_str());
-
+	
 	if (xmode == "output" ||
 	    xmode == "out" || 
 	    xmode == "OUTPUT" ||
@@ -58,7 +58,10 @@ PortRequest::PortRequest (const string &xdev,
 		status = Unknown;
 	}
 
-	if (xtype == "ALSA/RAW" ||
+	if (xtype == "JACK" ||
+		   xtype == "jack") {
+		type = Port::JACK_Midi;
+	} else if (xtype == "ALSA/RAW" ||
 		   xtype == "alsa/raw") {
 		type = Port::ALSA_RawMidi;
 	} else if (xtype == "ALSA/SEQUENCER" ||
diff --git a/libs/pbd/pbd/unknown_type.h b/libs/pbd/pbd/unknown_type.h
new file mode 100644
index 0000000000..fddc1aeddb
--- /dev/null
+++ b/libs/pbd/pbd/unknown_type.h
@@ -0,0 +1,11 @@
+#ifndef __pbd_unknown_type_h__
+#define __pbd_unknown_type_h__
+
+#include <exception>
+
+class unknown_type : public std::exception {
+  public:
+	virtual const char *what() const throw() { return "unknown type"; }
+};
+
+#endif /* __pbd_unknown_type_h__ */
diff --git a/libs/sigc++2/ChangeLog b/libs/sigc++2/ChangeLog
index 23c59ee3fa..8e02aef058 100644
--- a/libs/sigc++2/ChangeLog
+++ b/libs/sigc++2/ChangeLog
@@ -1,604 +1,3 @@
-2.0.17:
-
-2005-12-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/macros/signal.h.m4: Make all operator--() methods 
-	return by reference, like the operator++() methods. 
-	Bug #304402 from John Profic.
-
-This is the libsigc-2-0 branch, for maintenance of libsigc++ 2.0.
-API/ABI-compatible API-addition happens in the HEAD branch.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/functors/slot_base.cc: 
-	slot_base::disconnect(): Set call_ to 0, 
-	to invalidate the slot, even if parent_ is 0. 
-	I think parent_ is, for instance, a signal, but 
-	disconnect should still work on a slot that is not 
-	connected to a signal, because a slot can be invoked 
-	directly.
-	Fixes bug #311057 from James Lin.
-
-2005-12-01  Murray Cumming <murrayc@murrayc.com>
-
-	* tests/Makefile.am:
-	* tests/test_slot_disconnect.cc: Added test 
-	case from bug #311057.
-
-2005-11-16  Philipp Berndt  <philipp.berndt@gmx.net>
-
-	* sigc++/adaptors/macros/exception_catch.h.m4: Make member
-	exception_catch_functor<T_functor, T_catcher, void>::catcher_
-	public so that it can be accessed by visit_each()
-	(bug fixed for generalization on 2004-11-06)
-
-2.0.16:
-
-2005-08-01  Neal E. Coombes  <nealc@trdlnk.com>
-
- 	* sigc++/signal_base.h: Updated the documentation for temp_slot_list
- 	as requested in bug #303896.
-
-2005-08-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/adaptors/hide.h.m4: Added missing 
-	) in call to sun_forte_workaround(), fixing
-	build on SUN Forte 5.5. Bug #312020.
-
-2005-08-19  Bruno Martinez <brunom@fing.edu.uy>
-
-	* sigc++/type_traits.h: Renamed
-	::sigc::is_base_and_derived::internal to 
-	::sigc::is_base_and_derived::internal_class
-	in order to avoid conflict with
-	namespace internal. 
-
-2005-07-13  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/manual/libsigc_manual.xml: Correct mentions of 
-	1.2 stuff instead of 2.0. Patch in bug #310213 from 
-	pebble.org.uk.  
-
-2005-07-13  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/manual/libsigc_manual.xml: Fixed typo 
-	found by Antonio Coralles.
-
-2005-07-09  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/macros/signal.h.m4: Did the same (see 
-	last commit) for slot_const_iterator and 
-	slot_iterator_buf.
-
-2005-07-09  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/macros/signal.h.m4: slot_iterator:
-	operator--() now returns value, not reference, like 
-	operator++() already did. This caused crashes when 
-	using --no-inline with g++. Bug #308651 by 
-	Michael Andres.
-
-2.0.15:
-
-2005-07-04  Philip Langdale  <plangdale@vmware.com>
-
-	* sigc++/adaptors/macros/compose.h.m4: Add a setter typedef to 
-	compose*_functor and use it instead of the (incorrect) getter 
-	typedef in the compose* specialization of visit_each<>().
-	This corrects the lifetime management of slots created with 
-	compose(). Bug #308433.
-
-2005-06-13  Marek Rouchal  <marek.rouchal@infineon.com>
-
-	* tests/test_deduce_result_type.cc: Specify int return type 
-	for main(), to be more ISO C++ compliant. Bug #307478.
-
-2005-06-11  Andris Pavenis <pavenis@latnet.lv>
-
-	* sigc++/adaptors/lambda/macros/base.h.m4:
-	* sigc++/adaptors/lambda/macros/select.h.m4
-	* sigc++/adaptors/macros/hide.h.m4: Specify only a type (not a
-	parameter name) for unused member function parameters
-
-2005-06-12  Paul Pogonyshev  <pogonyshev@gmx.net>
-
-	* configure.ac: 
-	* scripts/cxx.m4: 
-	* sigc++config.h.in: Add test for whether the compiler allows
-	referencing to member functions of the class/structure being
-	declared from a definition of a static member variable.
-	Supposedly a generic solution for GCC 3.2 compilation problems.
-
-	* sigc++/type_traits.h: Define SIGC_WRAP_IS_BASE_CLASS_ based on
-	results of the above test.
-	(struct is_base_and_derived): Wrap up is_base_class_() functions
-	in an internal class if SIGC_WRAP_IS_BASE_CLASS_ is defined.
-
-2005-06-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/adaptors/macros/bind.h.m4:
-	* sigc++/functors/macros/slot.h.m4:
-	* sigc++/macros/signal.h.m4: Use CALL_SIZE instead of 
-	hard-coded 7s and 6s.
-
-2.0.14:
-
-2005-06-10  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/visit_each.h: Make the 
-        limit_derived_target::with_type inner class an outer class, 
-	to satisfy the SUN CC 5.7 compiler, though I think it is a 
-	compiler bug. Bug #302098 has the test case.
-
-2.0.13:
-
-2005-06-07  Murray Cumming <murrayc@murrayc.com>
-
-	* tests/test_compatibility.cc: Specify the actual class when 
-	using test_int(), instead of the derived class, to fix the build 
-	on SUN Forte CC 5.5. Patch from Friedemann Kleint in 
-	Bug #305647
-
-2005-06-07  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/macros/signal.h.m4: signal_emit::emit(): Use scope to 
-	ensure a certain order of destruction of the member variables, to 
-	avoid a leak on MSVC++. Patch by Andreas Ames in Bug #306249.
-
-2005-06-07  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/macros/signal.h.m4: Added comments about commenting-out
-        SIGC_TYPEDEF_REDEFINE_ALLOWED when using SUN Forte CC 5.7, 
-        because I can not seem to create a test for it.
-
-2005-06-07  Murray Cumming <murrayc@murrayc.com>
-
-	* configure.ac:
-	* scripts/cxx_std.m4:
-	* sigc++/macros/signal.h.m4:
-	* sigc++config.h.in: Added check for 
-	the non-standard SUN Forte reverse_iterator<>,
-	and used it. This is based on the same stuff in 
-	gtkmm.
-
-2005-06-07  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/visit_each.h: limit_derived_target(): Just some whitespace 
-        changes.
-
-2005-05-16  Neal E. Coombes  <nealc@trdlnk.com>
- 	
-	* sigc++/signal_base.h:  Modified temp_slot_list to be a temporary view
-	into a slot list.  Instead of emptying the original it now simply tacks
-	a placeholder to the end of the original.  It then uses this as it's
-	'end' iterator.  This should allow for conscious recursiveness, as well
-	as inserting a slot to any position in the slot list during emittion.
-	See bug #303896.
-
-2005-06-04  Friedemann Kleint <kleint@bifab.de>
-
-	* sigc++/macros/limit_reference.h.m4: 
-	visit_each() template specializations: 
-	Mention the bool I_derives_trackable 
-	template type, to fix the build on Solaris 
-	Forte 5.5.
-
-2.0.12:
-
-2005-05-06  Régis Duchesne <hpreg@vmware.com>
-
-	* sigc++/macros/limit_reference.h.m4 (added):
-	* sigc++/Makefile.am:
-	New class that just stores a reference, and makes sure that if the
-	reference derives from trackable, then the trackable reference will be
-	used instead of the derived reference in visit_each().
-	* sigc++/functors/macros/mem_fun.h.m4: Better fix for bug #169225 by
-	Régis Duchesne and Christian Hammond, based on the new limit_reference
-	class.
-	* sigc++/adaptors/bound_argument.h (added): New class (built upon the
-	new limit_reference class) that handles all 3 kinds of bound arguments:
-	by value, by reference, and by constant reference. References are
-	unwrapped in the bound_argument's constructor.
-	* sigc++/adaptors/macros/bind.h.m4: Fix for bug #302327 by Régis
-	Duchesne. Bound arguments now need to know whether they are passed by
-	reference or not. So bind() now builds bind_functor instances using
-	'reference_wrapper<Foo>' types, instead of 'Foo &' types. The
-	bind_functor code is modified to compensate.
-	* sigc++/adaptors/macros/bind_return.h.m4: Similar fix for a similar
-	bug (unfiled) with bound return arguments.
-	* sigc++/reference_wrapper.h:
-	* sigc++/type_traits.h:
-	The reference_wrapper class is only used in bound_argument.h. Put
-	correct but unused code under #if 0.
-	* sigc++/adaptors/lambda/base.h: This file needs reference_wrapper.h,
-	but was incorrectly relying on type_traits.h to include it.
-	* tests/Makefile.am:
-	* tests/test_virtualbase_delete.cc (deleted):
-	* tests/test_virtualbase_delete_ref_param.cc (deleted):
-	* tests/test_limit_reference.cc (added):
-	Replaced test_virtualbase_delete*.cc with a simpler
-	test_limit_reference.cc which checks for all 3 aspects of the same bug
-	in one file.
-	* tests/test_bind_ref.cc: Slots must use 'Foo &' types. We were lucky
-	this broken usage worked before this change. The change in
-	type_traits.h made this bug obvious, by preventing the code to compile.
-	* tests/test_bind_return.cc: After my change, bind() and bind_return()
-	must use 'reference_wrapper<Foo>' types.
-	* tests/test_custom.cc: Made this test a no-op (so it does not perturb
-	'make check' on released versions of the library) and made it a
-	template ready to be modified by hackers.
-
-2005-05-01  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/functors/slot_base.cc: 
-	slot_base::slot_base(src): If the source 
-	slot_base has a null rep->call_, meaning that the 
-	slot is invalid, just return a default-constructed 
-	slot, to prevent the crash shown in 
-	tests/tests_copy_invalid_slot.cc. Bug #302515 by 
-	Régis Duchesne.
-
-2005-05-01  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/functors/macros/mem_fun.h.m4: bound_*<>: 
-	Add a new is_base_and_derived<sigc::trackable> 
-	parameter to the template and thereby provide a 
-	specialization for T_Obj types that derive from 
-	sigc::trackable. This prevents a crash when casting 
-	from the derived type to sigc::trackable after the 
-	derived destructor has run. This cast can sometimes 
-	fail when using multiple inheritance, at least with 
-	g++. Bug #169225 by Régis Duchesne and Christian 
-	Hammond.
-	* sigc++/type_traits.h: Add documenation for 
-	the internal is_base_and_derived<> template, which 
-	allows us to specialize other templates for certain 
-	template types.
-
-2005-04-28  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/type_traits.h: Added comments for users of 
-	g++ 3.2.
-
-2005-04-28  Murray Cumming <murrayc@murrayc.com>
-
-	* tests/Makefile.am:
-	* tests/test_virtualbase_delete.cc: Added 
-	simplified test case from bug #169225. We have a patch 
-	to make this succeed but I am not ready to commit it 
-	just yet.
-
-2005-04-27  Murray Cumming <murrayc@murrayc.com>
-
-	* tests/Makefile.am:
-	* tests/test_custom.cc:
-	Added a place to put extra test code, so I don't have 
-	to keep installing my crazy libsigc++ versions.
-
-2005-04-27  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/visit_each.h: Revert back to the non-explicit 
-	template call, because we can not specify the 
-	template specialization so easily, because the 
-	specializations have different numbers of types.
-	* tests/Makefile/am:
-	* tests/test_bind_ref.cc: Add a simple test only for 
-	sigc::ref disconnection.
-
-2005-04-26  Murray Cumming <murrayc@murrayc.com>
-
-	* sigc++/visit_each.h: Use the explicit template 
-	specialization, needed for Tru64 and AIX compilers. 
-	This causes a crash in some uses of sigc::ref() 
-        (when using g++ 3.3.4 or 3.3.5 , but not with 3.4) but 
-	seems to fix a crash in some uses of multiple inheritance 
-	(bug #169225).
-	* tests/test_bind.cc: Comment out the crashing (not with 
-	g++ 3.4) use of sigc::ref() with an explanatory comment.
-	
-2.0.11:
-
-2005-03-09  Cedric Gustin <cedric.gustin@swing.be>
-
-	* Makefile.am: Moved MSVC_Net2003 directory to SUBDIRS.
-	* MSVC_Net2003/Makefile.am: Added blank.cpp to EXTRA_DIST.
-	* MSVC_Net2003/libsigc++2_msvcNet2003.sln: Removed
-	test_accumulated and test_lambda projects as the tests are
-	disabled in the standard, configure-based build.
-	* MSVC_Net2003/MSVC_Net2003/libsigc++2_msvcNet2003.vcproj:
-	Generate a PDB file in the Debug target.
-
-2005-03-05  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/website/stable.html: Mention actual supported compilers.
-	* docs/website/docs.html: Removed broken examples links. Change 
-	reference link to the reference overview page.
-
-2005-02-23  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/functors/slot_base.h: Make slot_base::operator=() public, to 
-	fix the build with SUN Forte C++ 5.5 and Tru64.
-
-2.0.10:
-
-2005-02-20  Murray Cumming  <murrayc@murrayc.com>
-
-	* tests/test_slot.cc, test_disconnect.cc: #included <new> to avoid 
-	an unresolved symbol error with the Tru64 compiler. Solution found by 
-	Tim Mooney in bug #161503.
-
-2005-02-20  Martin Schulze  <mschulze@cvs.gnome.org>
-
-	* sigc++/signal_base.h: Add some documentation.
-
-2005-02-20  Martin Schulze  <mschulze@cvs.gnome.org>
-
-	* sigc++/signal_base.cc: Reset deferred_ flag to false in
-	signal_impl::sweep() (Neal E. Coombes). Partly fixes bug #167714.
-
-2005-02-11  Martin Schulze  <mschulze@cvs.gnome.org>
-
-	* docs/manual/Makefile.am: Set the correct group in post-html.
-
-2005-02-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/website/doc.shtml: Fix typo in url for reference docs. Found by 
-	James Lin.
-
-2005-02-06  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/signal_base.h: temp_slot_list::begin(), end(): Actually 
-	return the iterators.
-
-2005-02-03  Neal E. Coombes <nealc@trdlnk.com>
-
-	* sigc++/signal_base.h: Add temp_slot_list struct to facilitate
-	allowing new connections to a signal during an emittion without
-	affecting that emittion.
-	* sigc++/macros/signal.h.m4: Use the new struct temp_slot_list to
-	prevent connections made during an emittion from being called in the
-	same emittion (which has the potential of causing things like
-	infinite loops).  This guarantees an emittion will be finite, as well
-	as maintaining any order of emittion guarantees that may have already
-	been in place.
-	
-2.0.9:
-
-2005-02-02  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/visit_each.h: visit_each_type(): Reverted the change, so that 
-	we do not specify the template types ot visit_each<>(), because it 
-	crashes on g++ 3.3.4 (but not g++ 3.4.2). Added a comment telling users 
-	of AIX (and maybe IRIX MipsPro and Tru64) to use the alternative version 
-	if they have compilation problems.
-
-2005-02-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/adapators/macros/base.h.m4: Add sigc::var<>() documentation, 
-	from Roger Ferrer Ibáñez in bug #149483.
-
-2005-02-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/adaptors/macros/compose.h.m4: In the template specializations 
-	of visit_each(): As before, specify the specific other template 
-	specializations of visit_each that we use. Needed by AIX.
-	* tests/Makefile.am: Reenabled most tests, because AIX can now 
-	build them.
-
-2005-02-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/visit_each.h: visit_each_type(): Specify the specific 
-	template specialization of visit_each<>() to use. The AIX compiler, 
-	and possibly the Tru64 compiler, need this extra hint.
-
-2005-02-01  Murray Cumming  <murrayc@murrayc.com>
-
-	* bind.h.m4: Define bind_functor::operator() inline because the AIX 
-	compiler/linker sometimes fails to find it when it is defined 
-	outside of the class.
-
-2.0.8:
-
-2005-01-30  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/type_traits.h: is_base_and_derived: Added 
-	avoid_gcc3_warning_(), to avoid an incorrect warning when using 
-	g++ 3.3.5
-
-2005-01-28  Liza Klerck   <liza@trdlnk.com>
-
-	* sigc++/functors/macros/mem_fun.h.m4: Add a sigc:: namespace 
-	prefix to the nested use of visit_each(), to avoid ambiguity when 
-	using 2 versions of the libsigc++ API inside different namespace.
-	
-2005-01-27  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/adaptors/macros/adaptor_trait.h.m4: Add a sigc:: namespace 
-	prefix to the nested use of visit_each(), to avoid ambiguity when 
-	using 2 versions of the libsigc++ API inside different namespace, 
-	which is not very advisable anyway. Bug #165222 from 
-	liza at trdlnk.com.
-
-2.0.7:
-
-2005-01-24  Cedric Gustin <cedric.gustin@swing.be>
-
-	* sigc++config.h.in : Moved the SIGC_USING_STD macro definition
-	out of the SIGC_CONFIGURE section. We also need it for MSVC.
-	* MSVC_Net2003/.cvsignore : Added .def and .aps files
-	* MSVC_Net2003/Makefile.am: Rewrote rule for local copy of
-	sigc++config.h (required for 'make distcheck').
-	* MSVC_Net2003/libsigc++2_msvcNet2003.sln: Added test_retype and
-	test_disconnect_during_emit tests.
-	* MSVC_Net2003/tests/test_disconnect_during_emit/*,
-	MSVC_Net2003/tests/test_retype/*: Initial commit.
-
-2005-01-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* tests/: Disabled the test_accumulator, test_bind, and test_compose 
-	tests, and part of test_mem_fun because the AIX xlC compiler can not 
-	build them, but it can still do most things, including the examples.
-	See the comments in tests/Makefile.am.
-
-2005-01-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/adaptors/bind.h.m4: non-member operator()(): Specify the 
-	extra nil arguments in the templated class name prefix. Oddly, the 
-	AIX xlC compiler says that the type of the first parameter does not 
-	match the template if you don't do this.
-
-2005-01-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/type_traits.h: is_base_and_derived struct: Move the 
-	is_base_class_() functions out of the inner class, because the AIX 
-	xlC compiler does not like that - see the comments in the code.
-	* sigc++/adaptors/bind.h.m4: Add the extra nil template types to 
-	the template specializations, as in slot and signal.
-	
-2005-01-21  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/functors/macros/slot.h.m4, sigc++/macros/signal.h.m4: 
-	slot and signal template specialization for 
-	various numbers of template args: In the class slot line, specify 
-	all the remaining template types as null, instead of expecting the 
-	compiler to guess them in itself. This partly fixes the build on 
-	AIX with the xlC compiler. Bug #164685.
-
-2005-01-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/type_traits: struct is_base_and_derived: Make the test inner 
-	struct a friend, so that it can use the big inner struct. This is 
-	required by the Tru64 compiler.
-	* sigc++/adaptors/lambda/base.h: Put the unwrap_lambda_value() 
-	definitions at the top, because Tru64 (understandably) needs them to 
-	be declared before use.
-
-2005-01-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* scripts/: Added cxx_std.m4, with a test copied from 
-	glibmm/scripts/cxx_std.m4 to check if the compiler has the std:: 
-	namespace.
-	* sigcconfig.h: #undef the new #define and add SIGC_USING_STD(), 
-	like GLIBMM_USING_STD, to put stuff in the std:: namespace when it 
-	is not there already,
-	* configure.in: Used the new test.
-	* tests/*: Uses SIG_USING_STD() for every std:: thing that we use.
-	This is needed by the Tru64 and HP-UX compilers when using their 
-	defaults.
-
-2005-01-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: AC_INIT(): Provide the extra tarball name parameter, 
-	so that it does not create a libsigc--- tarball.
-
-2005-01-19  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: AC_INIT(): Use libsigc++ instead of sigc++, attempting 
-	to get the correct tarball name.
-
-2005-01-18  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Used the autoconf 2.93 and AM_INIT_AUTOMAKE() 
-	technique to specify ustar format for the tarball, to prevent files 
-	with long file names from appearing at the top of the tarball. 
-	Based on the same fix in gtkmm 2.6.
-
-2005-01-18  Murray Cumming  <murrayc@murrayc.com>
-
-	* sigc++/functors/macros/slot_h.m4: Specify the base class when 
-	using the rep_ member variable. This stops the HP-UX aCC compiler 
-	from saying that a Nonstatic member  is referenced in a nested class, 
-	local class or static member initializer. Bug #150719.
-
-2005-01-18  Murray Cumming  <murrayc@murrayc.com>
-
-	* Bug #159597 - patch from e97_far at e.kth.se to replace C-style 
-	casts with reinterpret_cast<> and static_cast<> to avoid warnings.
-
-2005-01-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/manual/Makefile.am: Specifying html/index.html instead of 
-	just the html directory as a target seems to fix distcheck problems.
-	I can also now confirm that the install works on solaris, when using 
-	gmake, though not when using make.
-
-2005-01-17  Murray Cumming  <murrayc@murrayc.com>
-
-	* MSVC_Net2004/Makefile.am: Add built files to DISTCLEANFILES to fix 
-	the distcheck.
-	* docs/reference/Makefile.am, manual/Makefile.am: Specify $srcdir in 
-	paths, to fix distcheck of the manual, and maybe fix install problems 
-	on Solaris.
-
-2005-01-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/website/stable.html: Updated the text about binary packages.
-	* docs/website/docs.html: Link to the 2.0 documentation instead of the 
-	1.2 documentation.
-
-2004-12-17  GregSchussman  <schussman@slac.stanford.edu>
- 
- 	* glossary.shtml: Clean up punctuation, make definitions complete
-        sentences, and add clarifications for certain definitions according to
-        what Murray Cumming's suggestions and answers to my questions.
- 	Bug #161580.
-
-2005-01-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/: Added manual, copied from the libsigc++-1.2 cvs module, 
-	and updated it for the new 2.0 API.
-
-2005-01-11  Murray Cumming  <murrayc@murrayc.com>
-
-	* docs/: Added website, copied from the libsigc++-1.2 cvs module.
-	We will use it from here from now on.
-
-2004-12-11  Cedric Gustin <cedric.gustin@swing.be>
-
-	* configure.ac : parse version tags at configure time (for
-	sigc-2.0.rc).
-	* MSVC_Net2003/sigc-2.0.rc.in : New resource file.
-	* MSVC_Net2003/Makefile.am: include sigc-2.0.rc in distribution.
-
-2004-12-08  Cedric Gustin <cedric.gustin@swing.be>
-
-	* MSVC_Net2003/Makefile.am: get sigc++config.h from $(top_builddir)
-	instead of $(top_srcdir).
-
-2004-12-08  Cedric Gustin <cedric.gustin@swing.be>
-
-	* MSVC_Net2003/*/*.vcproj: Renamed libsigc++ target to
-	sigc-2.0d.dll (Debug) and sigc-2.0.dll (Release). Added
-	$(SolutionDir) and $(SolutionDir)\.. to "Additional Include
-	Directories" in tests projects.
-	* sigc++config.h.in: Rewrote dllexport/dllimport macros for
-	MSVC, for better consistency with glibmm/gtkmm.
-	* MSVC_Net2003/Makefile.am: copy sigc++config.h from $(top_srcdir)
-	at build time.
-
-2004-11-27  Murray Cumming  <murrayc@murrayc.com>
-
-	* configure.in: Revert the AC_PROG_LIBTOOL change, so that this builds
-	with actually released libtool versions, and in jhbuild, so that it 
-	gets testing.
-
-2004-11-06  Martin Schulze  <mschulze@cvs.gnome.org>
-
-	* sigc++/adaptors/macros/exception_catch.h.m4: Make catcher_ member
-	public so that it can be accessed by visit_each() (bug reported on
-	ml by Philip Langdale <plangdale@vmware.com>).
-
-2004-10-24  Martin Schulze  <mschulze@cvs.gnome.org>
-
-	* MSVC_Net2003/*/*.vcproj: Link with the "multithreaded DLL" runtime
-	libraries and enable RTTI for the MSVC build
-	(patch from Timothy M. Shead <tshead@k-3d.com>).
-	* MSVC_Net2003/*/.cvsignore: Hide generated build files from cvs
-	(patch from Timothy M. Shead <tshead@k-3d.com>).
-
-2.0.6:
-
 2004-10-12  Martin Schulze  <mschulze@cvs.gnome.org>
 
 	* MSVC_Net2003/*/*.vcproj, MSVC_Net2003/blank.cpp: Fix project files
diff --git a/libs/sigc++2/Makefile.am b/libs/sigc++2/Makefile.am
index 64c25e5ea8..03d67389c6 100644
--- a/libs/sigc++2/Makefile.am
+++ b/libs/sigc++2/Makefile.am
@@ -5,7 +5,7 @@ EXTRA_DIST = autogen.sh sigc++config.h.in libsigc++-2.0.spec.in
 # ACLOCAL_FLAGS = -I scripts
 
 SUBDIRS      = sigc++ 
-DIST_SUBDIRS = $(SUBDIRS)
+DIST_SUBDIRS = $(SUBDIRS) 
 
 sigc_configdir = $(libdir)/sigc++-2.0/include
 sigc_config_DATA = sigc++config.h
@@ -28,4 +28,3 @@ dist-hook:
 	echo "**********************************************************"; \
 	echo; echo \
 	cp libsigc++-2.0.spec $(distdir)
-
diff --git a/libs/sigc++2/NEWS b/libs/sigc++2/NEWS
index e13c7dda96..83c29f5626 100644
--- a/libs/sigc++2/NEWS
+++ b/libs/sigc++2/NEWS
@@ -1,107 +1,21 @@
-2.0.17:
-
-* slot::disconnect(): Make this work.
-  sigc::connection::disconnect() already worked.
-  (James Lin, Murray Cumming)
-* visit_each compilation problem fixed.
-  (Philipp Berndt)
-
-2.0.16:
-
-* Fixed build for SUN Forte C++ 5.5
-* Fixed build for MSVC++ 7.1
-* Fixed crash when using --no-inline with g++.
-
-2.0.15:
-
-* g++ 3.2 (and Mac OS X g++ 3.3) build fix.
-  (Paul Pogonyshev)
-* Compose: Fix slot lifetime regression introduced in 
-  2.0.9. (Philip Langdale)
-* tests: Small ISO C++ correctness fix (Marek Rouchal)
-* Don't specify unused function parameter names.
-  (Andris Pavenis)
-
-2.0.14:
-
-* SUN Forte 5.7 build fix for ambiguity when using 
-  inner template class. However, you still need the 
-  patch in bug #302098 to finish the build.
-
-2.0.13:
-
-* signal_emit::emit(): Ensure the correct order of 
-  destruction of the member variables, to avoid a leak.
-  (Andreas Ames, bug #306249)
-* Allow recursive signal emission again.
-  (Neal E. Coombes, bug #303896)
-* SUN Forte CC 5.5 build fixes:
-  - test_compatibility minor fix.
-  - visit_each() template specializations: 
-  Mention the bool I_derives_trackable template type,
-  (Friedemann Kleint, bug #305647)
- - Check for the non-standard SUN reverse_iterator,
-  and use alternative code if necessary.
-  (Murray Cumming)
-
-2.0.12:
-
-* Fixes crashes when using virtual inheritance, particularly 
-  with bound by-reference parameters, caused by casting 
-  from derived to base when the derived destructor has run.
-  (Régis Duchesne)
-  This might affect non-g++ compilers, so do tell us about 
-  any problems.
-
-2.0.11:
-
-* Build fixes for SUN Forte, Tru64
-  (Murray Cumming), and MSVC++ (Cedric Gustin).
-
-2.0.10:
-
-* tests: Include <new> to avoid unresolved symbols on Tru64.
-  (Tim Mooney)
-* When signal handlers are connected made during an emit
-  of the same signal, prevent them from being called in the
-  same emit, to prevent infinite loops.
-  (Neal E. Coombes)
-* Performance improvement in a corner case.
-  (Neal E. Coombes).
-
-2.0.9:
-
-* sigc::bind() now works with the AIX and Tru64 compilers.
-  See the comments in sigc++/visit_each.h: visit_each_type() 
-  if you have compilation problems.
-  (Murray Cumming)
-* sigc::var() is now documented. (Roger Ferrer Ibáñez)
-
-2.0.8:
-
-* Maybe avoid (incorrect) warning with g++ 3.3.5.
-  (Murray Cumming)
-* Fix namespace ambiguity when using multiple 
-  major versions of libsigc++. (Liza Klerck)
-
-2.0.7:
-
-* Now builds with the following compilers, in addition to 
-the existing GNU g++, SUN Forte CC 5.5, MSVC++ .Net 2003, 
-and Intel compilers: 
-- IBM AIX xlC v7
-- Tru64 C++ V6.5-042
-- IRIX MIPSpro 7.4.2m
-  (Older versions of all these compilers might also work.)
-  (Murray Cumming, www.thewrittenword.com)
-* MSVC++ .Net 2003 build improvements.
-  (Cedric Gustin, Timothy M. Shead)
-* Replace C-style casts with reinterpret_cast<> and 
-  static_cast<>. (e97_far at e.kth.se).
-* Documentation: Added manual, based on the manual in 
-  libsigc++ 1.2, but updated for the new API.
-  (Murray Cumming)
+*** libsigc++ 2.0:
 
+libsigc++ implements a typesafe callback system for standard C++. It
+allows you to define signals and to connect those signals to any
+callback function, either global or a member function, regardless of
+whether it is static or virtual.
+
+libsigc++ is used by gtkmm to wrap the GTK+ signal system. It does not depend 
+on GTK or gtkmm.
+
+libsigc++ 2.0 uses modern C++ mechanisms to achieve a highly flexible,
+yet typesafe callback system. It supports all features of libsigc++ 1.2
+and improves upon it with a simpler and more powerful API.
+
+This version of libsigc++ needs GNU g++ 3.2 or higher to compile.
+
+
+*** ChangeLog summary:
 
 2.0.6:
 
diff --git a/libs/sigc++2/SConscript b/libs/sigc++2/SConscript
index 8536d115c0..b29aefb0cd 100644
--- a/libs/sigc++2/SConscript
+++ b/libs/sigc++2/SConscript
@@ -9,8 +9,6 @@ sigc2_files = glob.glob('sigc++/*.cc') + glob.glob('sigc++/functors/*.cc') + glo
 Import('env install_prefix')
 sigc2 = env.Copy()
 
-sigc2.Append(CXXFLAGS='-DLIBSIGC_DISABLE_DEPRECATED')
-
 libsigc2 = sigc2.SharedLibrary('sigc++2', sigc2_files)
 
 if os.access ('autogen.sh', os.F_OK) :
diff --git a/libs/sigc++2/autogen.sh b/libs/sigc++2/autogen.sh
index b5943d3612..09597765c6 100755
--- a/libs/sigc++2/autogen.sh
+++ b/libs/sigc++2/autogen.sh
@@ -24,17 +24,12 @@ fi
 srcdir=`dirname $0`
 test -z "$srcdir" && srcdir=.
 
-PKG_NAME="sigc++"
-
-echo "Adding libtools."
-libtoolize --automake --copy --force
+#echo "Adding libtools."
+#libtoolize --automake --copy --force
 
 echo "Building macros."
 aclocal  -I "$srcdir/scripts" $ACLOCAL_FLAGS
 
-#echo "Building config header."
-#autoheader
-
 echo "Building makefiles."
 automake --add-missing --copy
 
diff --git a/libs/sigc++2/configure.ac b/libs/sigc++2/configure.ac
index 69ffddcd0e..3cb4724ba5 100644
--- a/libs/sigc++2/configure.ac
+++ b/libs/sigc++2/configure.ac
@@ -3,64 +3,27 @@ dnl
 dnl  Source for generating compiler independent libraries.
 dnl
 
-#We use pushdef here because we can't use shell variables before AC_INIT, but we want to use a variable with AC_INIT:
-dnl   thus make format_package-0.0.1.tar.gz 
-pushdef([FP_MAJOR_VERSION],     [2])
-pushdef([FP_MINOR_VERSION],     [0])
-pushdef([FP_MICRO_VERSION],     [17])
-pushdef([FP_EXTRA_VERSION],     [])
-pushdef([FP_VERSION], FP_MAJOR_VERSION.FP_MINOR_VERSION.FP_MICRO_VERSION[]FP_EXTRA_VERSION)
-# package name, version, support contact, tarball name.
-AC_INIT([libsigc++], FP_VERSION, [libsigc-list@gnome.org], [libsigc++])
-
-dnl AC_CONFIG_SRCDIR is required name a file which is unique to the package
+dnl INIT is required name a file which is unique to the package
 dnl just to prevent someone from copying the configure to the wrong package.
-AC_CONFIG_SRCDIR([sigc++])
-
-AC_PREREQ(2.59)
+AC_INIT(sigc++)
 
-#########################################################################
-#  Version and initialization
-#########################################################################
-[FP_MAJOR_VERSION]=FP_MAJOR_VERSION
-[FP_MINOR_VERSION]=FP_MINOR_VERSION
-[FP_MICRO_VERSION]=FP_MICRO_VERSION
-[FP_EXTRA_VERSION]=FP_EXTRA_VERSION
-[FP_VERSION]=FP_VERSION
-popdef([FP_MAJOR_VERSION])
-popdef([FP_MINOR_VERSION])
-popdef([FP_MICRO_VERSION])
-popdef([FP_EXTRA_VERSION])
-popdef([FP_VERSION])
-FP_RELEASE=$FP_MAJOR_VERSION.$FP_MINOR_VERSION
-AC_DEFINE_UNQUOTED(FP_MAJOR_VERSION, $FP_MAJOR_VERSION, [Major version of libsigc++])
-AC_DEFINE_UNQUOTED(FP_MINOR_VERSION, $FP_MINOR_VERSION, [Minor version of libsigc++])
-AC_DEFINE_UNQUOTED(FP_MICRO_VERSION, $FP_MICRO_VERSION, [Micro version of libsigc++])
-AC_SUBST(FP_VERSION)
-AC_SUBST(FP_RELEASE)
-AC_SUBST(FP_MAJOR_VERSION)
-AC_SUBST(FP_MINOR_VERSION)
-AC_SUBST(FP_MICRO_VERSION)
+dnl This version stuff is just for the packaging section of the tool.
+dnl   thus make format_package-0.0.1.tar.gz  
+FP_MAJOR_VERSION=2
+FP_MINOR_VERSION=0
+FP_MICRO_VERSION=6
+FP_VERSION=$FP_MAJOR_VERSION.$FP_MINOR_VERSION.$FP_MICRO_VERSION
 
 dnl For automake.
 VERSION=$FP_VERSION
 PACKAGE=libsigc++
 
-# Initialize automake stuff
-# tar-ustar asks it to use a sensible tar format that can handle long filenames.
-AM_INIT_AUTOMAKE([1.9 tar-ustar])
+dnl Initialize automake stuff
+AM_INIT_AUTOMAKE($PACKAGE, $VERSION)
 
 dnl Specify a configuration file:
 AC_CONFIG_HEADER(sigc++config.h)
 
-dnl Macros to support windows platforms
-AC_CYGWIN
-#AC_MINGW32
-AC_EXEEXT
-
-dnl this package needs m4
-AC_CHECK_PROGS(M4, gm4 m4, m4)
-
 dnl disable autoheader
 AUTOHEADER=':'
 
@@ -71,34 +34,16 @@ dnl Using C compiler
 AC_PROG_CC
 AC_PROG_CPP
 
-dnl Used for enabling the "-no-undefined" flag while generating DLLs
-dnl Borrowed from the official gtk+-2 configure.in
-AC_MSG_CHECKING([for some Win32 platform])
-case "$host" in
-  *-*-mingw*|*-*-cygwin*)
-    platform_win32=yes
-    ;;
-  *)
-    platform_win32=no
-    ;;
-esac
-AC_MSG_RESULT([$platform_win32])
-AM_CONDITIONAL(PLATFORM_WIN32, test "$platform_win32" = "yes")
-
 dnl Using libtool
 AC_CONFIG_MACRO_DIR(scripts)
-AC_LIBTOOL_WIN32_DLL
-dnl: Use with libtool 1.5a instead of AM_PROG_LIBTOOL: LT_INIT
-AM_PROG_LIBTOOL
+dnl LT_INIT
+dnl AM_PROG_LIBTOOL
 
 dnl Using C++ compiler
 AC_PROG_CXX
 AC_LANG_CPLUSPLUS
 
 SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD()
-SIGC_CXX_SELF_REFERENCE_IN_MEMBER_INITIALIZATION()
-SIGC_CXX_HAS_NAMESPACE_STD()
-SIGC_CXX_HAS_SUN_REVERSE_ITERATOR()
 
 if test "X$config_error" = "Xyes" ; then
   AC_ERROR(
@@ -116,5 +61,4 @@ AC_OUTPUT([
 
   sigc++/Makefile
   libsigc++-2.0.spec
-
 ])
diff --git a/libs/sigc++2/scripts/cxx.m4 b/libs/sigc++2/scripts/cxx.m4
index 11f1969399..8753b53827 100644
--- a/libs/sigc++2/scripts/cxx.m4
+++ b/libs/sigc++2/scripts/cxx.m4
@@ -47,7 +47,6 @@ AC_TRY_COMPILE(
   AC_MSG_RESULT([$sigcm_cxx_gcc_template_specialization_operator_overload])
 ])
 ])
-
 AC_DEFUN([SIGC_CXX_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD],[
 AC_MSG_CHECKING([if C++ compiler supports the use of a particular specialization when calling operator() template methods omitting the template keyword.])
 AC_TRY_COMPILE(
@@ -93,30 +92,3 @@ AC_TRY_COMPILE(
   AC_MSG_RESULT([$sigcm_cxx_msvc_template_specialization_operator_overload])
 ])
 ])
-
-
-AC_DEFUN([SIGC_CXX_SELF_REFERENCE_IN_MEMBER_INITIALIZATION], [
-AC_MSG_CHECKING([if C++ compiler allows usage of member function in initialization of static member field.])
-AC_TRY_COMPILE(
-[
-  struct test
-  {
-    static char  test_function();
-
-    // Doesn't work with e.g. GCC 3.2.  However, if test_function()
-    // is wrapped in a nested structure, it works just fine.
-    static const bool  test_value
-      = (sizeof(test_function()) == sizeof(char));
-  };
-],
-[],
-[
-  sigcm_cxx_self_reference_in_member_initialization=yes
-  AC_DEFINE([SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION],[1],
-            [does c++ compiler allows usage of member function in initialization of static member field.])
-  AC_MSG_RESULT([$sigcm_cxx_self_reference_in_member_initialization])
-],[
-  sigcm_cxx_self_reference_in_member_initialization=no
-  AC_MSG_RESULT([$sigcm_cxx_self_reference_in_member_initialization])
-])
-])
diff --git a/libs/sigc++2/scripts/cxx_std.m4 b/libs/sigc++2/scripts/cxx_std.m4
deleted file mode 100644
index b2ff03e385..0000000000
--- a/libs/sigc++2/scripts/cxx_std.m4
+++ /dev/null
@@ -1,77 +0,0 @@
-cv_cxx_has_namespace_std
-## SIGC_CXX_HAS_NAMESPACE_STD()
-##
-## Test whether libstdc++ declares namespace std.  For safety,
-## also check whether several randomly selected STL symbols
-## are available in namespace std.
-##
-## On success, #define SIGC_HAVE_NAMESPACE_STD to 1.
-##
-AC_DEFUN([SIGC_CXX_HAS_NAMESPACE_STD],
-[
-  AC_CACHE_CHECK(
-    [whether C++ library symbols are declared in namespace std],
-    [sigc_cv_cxx_has_namespace_std],
-  [
-    AC_TRY_COMPILE(
-    [
-      #include <algorithm>
-      #include <iterator>
-      #include <iostream>
-      #include <string>
-    ],[
-      using std::min;
-      using std::find;
-      using std::copy;
-      using std::bidirectional_iterator_tag;
-      using std::string;
-      using std::istream;
-      using std::cout;
-    ],
-      [sigc_cv_cxx_has_namespace_std="yes"],
-      [sigc_cv_cxx_has_namespace_std="no"]
-    )
-  ])
-
-  if test "x${sigc_cv_cxx_has_namespace_std}" = "xyes"; then
-  {
-    AC_DEFINE([SIGC_HAVE_NAMESPACE_STD],[1], [Defined when the libstdc++ declares the std-namespace])
-  }
-  fi
-])
-
-## SIGC_CXX_HAS_SUN_REVERSE_ITERATOR()
-##
-## Check for Sun libCstd style std::reverse_iterator, which demands more than just one template parameter.
-## and #define SIGC_HAVE_SUN_REVERSE_ITERATOR if found.
-##
-AC_DEFUN([SIGC_CXX_HAS_SUN_REVERSE_ITERATOR],
-[
-  AC_REQUIRE([SIGC_CXX_HAS_NAMESPACE_STD])
-
-  AC_CACHE_CHECK(
-    [for non-standard Sun libCstd reverse_iterator],
-    [sigc_cv_cxx_has_sun_reverse_iterator],
-  [
-    AC_TRY_COMPILE(
-    [
-      #include <iterator>
-      #ifdef SIGC_HAVE_NAMESPACE_STD
-      using namespace std;
-      #endif
-    ],[
-      typedef reverse_iterator<char*,random_access_iterator_tag,char,char&,char*,int> ReverseIter;
-    ],
-      [sigc_cv_cxx_has_sun_reverse_iterator="yes"],
-      [sigc_cv_cxx_has_sun_reverse_iterator="no"]
-    )
-  ])
-
-  if test "x${sigc_cv_cxx_has_sun_reverse_iterator}" = "xyes"; then
-  {
-    AC_DEFINE([SIGC_HAVE_SUN_REVERSE_ITERATOR],[1])
-  }
-  fi
-])
-
-
diff --git a/libs/sigc++2/scripts/libtool.m4 b/libs/sigc++2/scripts/libtool.m4
new file mode 100644
index 0000000000..1ceda32823
--- /dev/null
+++ b/libs/sigc++2/scripts/libtool.m4
@@ -0,0 +1,5767 @@
+# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
+
+m4_define([_LT_COPYING], [dnl
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
+# Free Software Foundation, Inc.
+#
+# This file is part of GNU Libtool:
+# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+])
+
+# serial 49 LT_INIT
+
+
+# LT_PREREQ(VERSION)
+# ------------------
+# Complain and exit if this libtool version is less that VERSION.
+m4_define([LT_PREREQ],
+[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
+       [m4_default([$3],
+		   [m4_fatal([Libtool version $1 or higher is required],
+		             63)])],
+       [$2])])
+
+
+# LT_INIT([OPTIONS])
+# --------------------------
+AC_DEFUN([LT_INIT],
+[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT
+dnl Autoconf doesn't catch unexpanded LT_ macros by default:
+m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
+m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW)$])dnl
+dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
+dnl unless we require an AC_DEFUNed macro:
+AC_REQUIRE([LTOPTIONS_VERSION])dnl
+AC_REQUIRE([LTSUGAR_VERSION])dnl
+AC_REQUIRE([LTVERSION_VERSION])dnl
+AC_REQUIRE([_LT_PROG_LTMAIN])dnl
+AC_BEFORE([$0], [LT_LANG])dnl
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS="$ltmain"
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+AC_SUBST(LIBTOOL)dnl
+
+# Set options
+_LT_SET_OPTIONS([$1])dnl
+
+_LT_SETUP
+
+# Only expand once:
+m4_define([LT_INIT])
+])# _LT_INIT
+
+# Old names:
+AU_DEFUN([AC_PROG_LIBTOOL],	    [LT_INIT])
+AU_DEFUN([AM_PROG_LIBTOOL],	    [LT_INIT])
+
+
+# _LT_SETUP
+# ---------
+m4_define([_LT_SETUP],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+_LT_DECL([], [host_alias], [0], [The host system])dnl
+_LT_DECL([], [host], [0])dnl
+dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_PROG_LD])dnl
+AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl
+AC_REQUIRE([AC_PROG_NM])dnl
+dnl
+AC_REQUIRE([AC_PROG_LN_S])dnl
+test -z "$LN_S" && LN_S="ln -s"
+_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
+dnl
+AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl
+AC_REQUIRE([AC_LIBTOOL_SYS_OLD_ARCHIVE])dnl
+AC_REQUIRE([AC_LIBTOOL_SYS_MAX_CMD_LEN])dnl
+AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])dnl
+AC_REQUIRE([AC_OBJEXT])dnl
+_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
+AC_REQUIRE([AC_EXEEXT])dnl
+_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
+dnl
+
+_LT_CONFIG_LIBTOOL_INIT([
+# See if we are running on zsh, and set the options which allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}" ; then
+   setopt NO_GLOB_SUBST
+fi
+])
+if test -n "${ZSH_VERSION+set}" ; then
+   setopt NO_GLOB_SUBST
+fi
+
+AC_LIBTOOL_OBJDIR
+
+AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
+_LT_AC_PROG_ECHO_BACKSLASH
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test "X${COLLECT_NAMES+set}" != Xset; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+Xsed='sed -e s/^X//'
+[sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']
+
+# Same as above, but do not quote variable references.
+[double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+# Constants:
+rm="rm -f"
+
+# Global variables:
+default_ofile=libtool
+ofile="$default_ofile"
+can_build_shared=yes
+
+# All known linkers require a `.a' archive for static linking (except M$VC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld="$lt_cv_prog_gnu_ld"
+
+old_CC="$CC"
+old_CFLAGS="$CFLAGS"
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    AC_PATH_MAGIC
+  fi
+  ;;
+esac
+
+AC_ARG_ENABLE([libtool-lock],
+    [AC_HELP_STRING([--disable-libtool-lock],
+	[avoid locking (might break parallel builds)])])
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Use C for the default configuration in the libtool script
+_LT_LANG_C_CONFIG
+_LT_LANG_DEFAULT_CONFIG
+_LT_CONFIG_COMMANDS
+])# _LT_SETUP
+
+
+# _LT_PROG_LTMAIN
+# ---------------
+# In libtool itself `ltmain.sh' is in the build tree, but everything else
+# ships it in the source tree, for completeness, if we find a copy in the
+# build tree use that before falling back to auxdir.
+#
+# Note that this code is called both from `configure', and `config.status'
+# now that we use AC_CONFIG_COMMANDS to generate libtool.  Notably,
+# `config.status' has no value for ac_aux_dir unless we are using Automake,
+# so we pass a copy along to make sure it has a sensible value anyway.
+AC_DEFUN([_LT_PROG_LTMAIN],
+[_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
+case $ac_aux_dir in
+  $srcdir)   ltmain=./ltmain.sh ;;
+  $srcdir/*) ltmain=`expr "$ac_aux_dir" : "$srcdir/\(.*\)"`/ltmain.sh ;;
+esac
+test -f "$ltmain" || ltmain="$ac_aux_dir/ltmain.sh"
+])# _LT_PROG_LTMAIN
+
+
+
+## ------------------------------------- ##
+## Accumulate code for creating libtool. ##
+## ------------------------------------- ##
+
+# So that we can recreate a full libtool script including additional
+# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
+# in macros and then make a single call at the end using the `libtool'
+# label.
+
+# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
+# ----------------------------------------
+# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL_INIT],
+[m4_ifval([$1],
+          [m4_append([_LT_OUTPUT_LIBTOOL_INIT],
+                     [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_INIT])
+
+# _LT_CONFIG_LIBTOOL([COMMANDS])
+# ------------------------------
+# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
+m4_define([_LT_CONFIG_LIBTOOL],
+[m4_ifval([$1],
+          [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
+                     [$1
+])])])
+
+# Initialize.
+m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
+
+
+# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
+# ---------------------------------------------------
+m4_define([_LT_CONFIG_SAVE_COMMANDS],
+[_LT_CONFIG_LIBTOOL([$1])
+_LT_CONFIG_LIBTOOL_INIT([$2])
+])
+
+
+# _LT_FORMAT_COMMENT([COMMENT])
+# -----------------------------
+# Add leading comment marks to the start of each line, and a trailing
+# full-stop to the whole comment if one is not present already.
+m4_define([_LT_FORMAT_COMMENT],
+[m4_ifval([$1], [
+m4_bpatsubst([$1], [^ *], [# ])]m4_bmatch([$1], [[!?.]$], [], [.])
+)])
+
+
+
+## ------------------------ ##
+## FIXME: Eliminate VARNAME ##
+## ------------------------ ##
+
+# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
+# -------------------------------------------------------------------
+# CONFIGNAME is the name given to the value in the libtool script.
+# VARNAME is the (base) name used in the configure script.
+# VALUE may be 0, 1 or 2 for a computed quote escaped value based on
+# VARNAME.  Any other value will be used directly.
+m4_define([_LT_DECL],
+[lt_if_append_uniq([lt_decl_varnames], [$2], [[, ]],
+    [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
+	[m4_ifval([$1], [$1], [$2])])
+    lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
+    m4_ifval([$4],
+	[lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
+    lt_dict_add_subkey([lt_decl_dict], [$2],
+	[tagged?], [m4_ifval([$5], [yes], [no])])])
+])
+
+
+# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
+# --------------------------------------------------------
+m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
+
+
+# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
+# -------------------------------------------------
+m4_define([lt_decl_tag_varnames],
+[_lt_decl_filter([tagged?], [yes], $@)])
+m4_define([_lt_decl_filter],
+[m4_case([$#],
+  [0], [m4_fatal([$0: too few arguments: $#])],
+  [1], [m4_fatal([$0: too few arguments: $#: $1])],
+  [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
+  [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
+  [lt_dict_filter([lt_decl_dict], $@)])[]dnl
+])
+
+
+# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
+# ---------------------------------------------------
+m4_define([lt_decl_quote_varnames],
+[_lt_decl_filter([value], [1], $@)])
+
+# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
+# ----------------------------------------------------
+m4_define([lt_decl_dquote_varnames],
+[_lt_decl_filter([value], [2], $@)])
+
+
+# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
+# ----------------------------------------------------
+m4_define([lt_decl_varnames_tagged],
+[_$0(m4_quote(m4_default([$1], [[, ]])),
+     m4_quote(m4_if([$2], [],
+		     m4_quote(lt_decl_tag_varnames),
+		  m4_quote(m4_shift($@)))),
+     m4_split(m4_normalize(m4_quote(_LT_TAGS))))])
+m4_define([_lt_decl_varnames_tagged], [lt_combine([$1], [$2], [_], $3)])
+
+
+# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
+# ------------------------------------------------
+m4_define([lt_decl_all_varnames],
+[_$0(m4_quote(m4_default([$1], [[, ]])),
+     m4_if([$2], [],
+	   m4_quote(lt_decl_varnames),
+	m4_quote(m4_shift($@))))[]dnl
+])
+m4_define([_lt_decl_all_varnames],
+[lt_join($@, lt_decl_varnames_tagged([$1],
+			lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
+])
+
+
+# _LT_CONFIG_STATUS_DECLARE([VARNAME])
+# ------------------------------------
+# Quote a variable value, and forward it to `config.status' so that its
+# declaration there will have the same value as in `configure'.  VARNAME
+# must have a single quote delimited value for this to work.
+m4_define([_LT_CONFIG_STATUS_DECLARE],
+[$1='`$echo "X$][$1" | $Xsed -e "$delay_single_quote_subst"`'])
+
+
+# _LT_CONFIG_STATUS_DECLARATIONS
+# ------------------------------
+# We delimit libtool config variables with single quotes, so when
+# we write them to config.status, we have to be sure to quote all
+# embedded single quotes properly.  In configure, this macro expands
+# each variable declared with _LT_DECL (and _LT_TAGDECL) into:
+#
+#    <var>='`$echo "X$<var>" | $Xsed -e "$delay_single_quote_subst"`'
+m4_define([_LT_CONFIG_STATUS_DECLARATIONS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
+    [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
+
+
+# _LT_LIBTOOL_TAGS
+# ----------------
+# Output comment and list of tags supported by the script
+m4_define([_LT_LIBTOOL_TAGS],
+[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
+available_tags="[]_LT_TAGS[]"dnl
+])
+
+# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
+# -----------------------------------
+# Extract the dictionary values for VARNAME (optionally with TAG) and
+# expand to a commented shell variable setting:
+#
+#    # Some comment about what VAR is for.
+#    visible_name=$lt_internal_name
+m4_define([_LT_LIBTOOL_DECLARE],
+[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
+					   [description])))[]dnl
+m4_pushdef([_libtool_name],
+    m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
+m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
+    [0], [_libtool_name=[$]$1],
+    [1], [_libtool_name=$lt_[]$1],
+    [2], [_libtool_name=$lt_[]$1],
+    [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
+m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
+])
+
+# _LT_LIBTOOL_CONFIG_VARS
+# -----------------------
+# Produce commented declarations of non-tagged libtool config variables
+# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
+# script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
+# section) are produced by _LT_LIBTOOL_TAG_VARS.
+m4_define([_LT_LIBTOOL_CONFIG_VARS],
+[m4_foreach([_lt_var],
+    m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
+    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
+
+# _LT_LIBTOOL_TAG_VARS(TAG)
+# -------------------------
+m4_define([_LT_LIBTOOL_TAG_VARS],
+[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
+    [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
+
+
+# _LT_AC_TAGVAR(VARNAME, [TAGNAME])
+# ---------------------------------
+m4_define([_LT_AC_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
+
+
+# _LT_CONFIG_COMMANDS
+# -------------------
+# Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
+# variables for single and double quote escaping we saved from calls
+# to _LT_DECL, we can put quote escaped variables declarations
+# into `config.status', and then the shell code to quote escape them in
+# for loops in `config.status'.  Finally, any additional code accumulated
+# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
+m4_define([_LT_CONFIG_COMMANDS],
+[AC_CONFIG_COMMANDS([libtool], [_LT_OUTPUT_LIBTOOL_COMMANDS], [
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+if test "X${CDPATH+set}" = Xset; then CDPATH=${ZSH_VERSION+.}:; export CDPATH; fi
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+_LT_CONFIG_STATUS_DECLARATIONS
+LTCC='$LTCC'
+compiler='$compiler_DEFAULT'
+
+# Quote evaled strings.
+for var in lt_decl_all_varnames([[ ]], lt_decl_quote_varnames); do
+    eval "lt_\$var=\\\\\\"\\\`\\\$echo \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
+done
+
+# Double-quote double-evaled strings.
+for var in lt_decl_all_varnames([[ ]], lt_decl_dquote_varnames); do
+    eval "lt_\$var=\\\\\\"\\\`\\\$echo \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
+done
+
+# Fix-up fallback echo if it was mangled by the above quoting rules.
+case \$lt_echo in
+*'\\\[$]0 --fallback-echo"')dnl "
+  lt_echo=\`\$echo "X\$lt_echo" | \$Xsed -e 's/\\\\\\\\\\\\\\\[$]0 --fallback-echo"\[$]/\[$]0 --fallback-echo"/'\`
+  ;;
+esac
+
+_LT_OUTPUT_LIBTOOL_INIT
+])
+])#_LT_CONFIG_COMMANDS
+
+
+# _LT_CONFIG(TAG)
+# ----------------------------
+# If TAG is the built-in tag, create an initial libtool script with a
+# default configuration from the untagged config vars.  Otherwise add code
+# to config.status for appending the configuration named by TAG from the
+# matching tagged config vars.
+m4_define([_LT_CONFIG],
+[_LT_CONFIG_SAVE_COMMANDS([
+  m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
+  m4_if(_LT_TAG, [C], [
+    # See if we are running on zsh, and set the options which allow our
+    # commands through without removal of \ escapes.
+    if test -n "${ZSH_VERSION+set}" ; then
+      setopt NO_GLOB_SUBST
+    fi
+
+    cfgfile="${ofile}T"
+    trap "$rm \"$cfgfile\"; exit 1" 1 2 15
+    $rm -f "$cfgfile"
+
+    cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+
+# `$echo "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
+# Generated automatically by config.status (GNU $PACKAGE$TIMESTAMP) $VERSION
+# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+#
+_LT_COPYING
+
+_LT_LIBTOOL_TAGS
+
+# ### BEGIN LIBTOOL CONFIG
+_LT_LIBTOOL_CONFIG_VARS
+_LT_LIBTOOL_TAG_VARS
+# ### END LIBTOOL CONFIG
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
+
+_LT_EOF
+
+  case $host_os in
+  aix3*)
+    cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test "X${COLLECT_NAMES+set}" != Xset; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+_LT_EOF
+    ;;
+  esac
+
+  _LT_PROG_LTMAIN
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)
+
+  mv -f "$cfgfile" "$ofile" ||
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+],
+[cat <<_LT_EOF >> "$ofile"
+
+dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
+dnl in a comment (ie after a #).
+# ### BEGIN LIBTOOL TAG CONFIG: $1
+_LT_LIBTOOL_TAG_VARS(_LT_TAG)
+# ### END LIBTOOL TAG CONFIG: $1
+_LT_EOF
+])dnl /m4_if
+],
+[m4_if([$1], [], [
+    PACKAGE='$PACKAGE'
+    VERSION='$VERSION'
+    TIMESTAMP='$TIMESTAMP'
+    rm='$rm'
+    ofile='$ofile'], [])
+])dnl /_LT_CONFIG_SAVE_COMMANDS
+])# _LT_CONFIG
+
+
+# C support is built-in for now
+m4_define([_LT_LANG_C_enabled], [])
+m4_define([_LT_TAGS], [])
+
+# LT_LANG(LANG)
+# -------------
+# Enable libtool support for the given language if not already enabled.
+AC_DEFUN([LT_LANG],
+[m4_case([$1],
+  [C],			[_LT_LANG(C)],
+  [C++],		[_LT_LANG(CXX)],
+  [Java],		[_LT_LANG(GCJ)],
+  [Fortran 77],		[_LT_LANG(F77)],
+  [Windows Resource],	[_LT_LANG(RC)],
+  [m4_ifdef([_LT_LANG_]$1[_CONFIG],
+    [_LT_LANG($1)],
+    [m4_fatal([$0: unsupported language: "$1"])])])dnl
+])# LT_LANG
+
+# _LT_LANG(LANGNAME)
+# ------------------
+m4_define([_LT_LANG],
+[m4_ifdef([_LT_LANG_]$1[_enabled], [],
+  [m4_append([_LT_TAGS], [$1 ])dnl
+  m4_define([_LT_LANG_]$1[_enabled], [])dnl
+  _LT_LANG_$1_CONFIG($1)])dnl
+])# _LT_LANG
+
+# _LT_LANG_DEFAULT_CONFIG
+# -----------------------
+m4_define([_LT_LANG_DEFAULT_CONFIG],
+[AC_PROVIDE_IFELSE([AC_PROG_CXX],
+  [LT_LANG(CXX)],
+  [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_F77],
+  [LT_LANG(F77)],
+  [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
+
+dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
+dnl pulling things in needlessly.
+AC_PROVIDE_IFELSE([AC_PROG_GCJ],
+  [LT_LANG(GCJ)],
+  [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
+    [LT_LANG(GCJ)],
+    [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
+      [LT_LANG(GCJ)],
+      [m4_ifdef([AC_PROG_GCJ],
+	[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
+       m4_ifdef([A][M_PROG_GCJ],
+	[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
+       m4_ifdef([LT_PROG_GCJ],
+	[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
+
+AC_PROVIDE_IFELSE([LT_PROG_RC],
+  [LT_LANG(RC)],
+  [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
+])# _LT_LANG_DEFAULT_CONFIG
+
+# Obsolete macros
+AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
+AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
+AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java])])
+
+
+# _LT_AC_SYS_COMPILER
+# -------------------
+AC_DEFUN([_LT_AC_SYS_COMPILER],
+[AC_REQUIRE([AC_PROG_CC])dnl
+
+_LT_DECL([LTCC], [CC], [1], [A C compiler])
+_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
+_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU C compiler?])
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+])# _LT_AC_SYS_COMPILER
+
+
+# _LT_AC_SYS_LIBPATH_AIX
+# ----------------------
+# Links a minimal program and checks the executable
+# for the system default hardcoded library path. In most cases,
+# this is /usr/lib:/lib, but when the MPI compilers are used
+# the location of the communication and MPI libs are included too.
+# If we don't find anything, use the default library path according
+# to the aix ld manual.
+m4_define([_LT_AC_SYS_LIBPATH_AIX],
+[AC_LINK_IFELSE(AC_LANG_PROGRAM,[
+aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+# Check for a 64-bit object if we didn't find anything.
+if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`; fi],[])
+if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+])# _LT_AC_SYS_LIBPATH_AIX
+
+
+# _LT_AC_SHELL_INIT(ARG)
+# ----------------------
+m4_define([_LT_AC_SHELL_INIT],
+[ifdef([AC_DIVERSION_NOTICE],
+	     [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
+	 [AC_DIVERT_PUSH(NOTICE)])
+$1
+AC_DIVERT_POP
+])# _LT_AC_SHELL_INIT
+
+
+# _LT_AC_PROG_ECHO_BACKSLASH
+# --------------------------
+# Add some code to the start of the generated configure script which
+# will find an echo command which doesn't interpret backslashes.
+m4_define([_LT_AC_PROG_ECHO_BACKSLASH],
+[_LT_AC_SHELL_INIT([
+# Check that we are running under the correct shell.
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+case X$ECHO in
+X*--fallback-echo)
+  # Remove one level of quotation (which was required for Make).
+  ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`
+  ;;
+esac
+
+echo=${ECHO-echo}
+if test "X[$]1" = X--no-reexec; then
+  # Discard the --no-reexec flag, and continue.
+  shift
+elif test "X[$]1" = X--fallback-echo; then
+  # Avoid inline document here, it may be left over
+  :
+elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
+  # Yippee, $echo works!
+  :
+else
+  # Restart under the correct shell.
+  exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}
+fi
+
+if test "X[$]1" = X--fallback-echo; then
+  # used as fallback echo
+  shift
+  cat <<_LT_EOF
+[$]*
+_LT_EOF
+  exit 0
+fi
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
+
+if test -z "$ECHO"; then
+if test "X${echo_test_string+set}" != Xset; then
+# find a string as large as possible, as long as the shell can cope with it
+  for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do
+    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
+    if (echo_test_string="`eval $cmd`") 2>/dev/null &&
+       echo_test_string="`eval $cmd`" &&
+       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
+    then
+      break
+    fi
+  done
+fi
+
+if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+   echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+   test "X$echo_testing_string" = "X$echo_test_string"; then
+  :
+else
+  # The Solaris, AIX, and Digital Unix default echo programs unquote
+  # backslashes.  This makes it impossible to quote backslashes using
+  #   echo "$something" | sed 's/\\/\\\\/g'
+  #
+  # So, first we look for a working echo in the user's PATH.
+
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for dir in $PATH /usr/ucb; do
+    IFS="$lt_save_ifs"
+    if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
+       test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
+       echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
+       test "X$echo_testing_string" = "X$echo_test_string"; then
+      echo="$dir/echo"
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+
+  if test "X$echo" = Xecho; then
+    # We didn't find a better echo, so look for alternatives.
+    if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
+       echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&
+       test "X$echo_testing_string" = "X$echo_test_string"; then
+      # This shell has a builtin print -r that does the trick.
+      echo='print -r'
+    elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
+	 test "X$CONFIG_SHELL" != X/bin/ksh; then
+      # If we have ksh, try running configure again with it.
+      ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+      export ORIGINAL_CONFIG_SHELL
+      CONFIG_SHELL=/bin/ksh
+      export CONFIG_SHELL
+      exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}
+    else
+      # Try using printf.
+      echo='printf %s\n'
+      if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
+	 echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
+	 test "X$echo_testing_string" = "X$echo_test_string"; then
+	# Cool, printf works
+	:
+      elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+	   test "X$echo_testing_string" = 'X\t' &&
+	   echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+	   test "X$echo_testing_string" = "X$echo_test_string"; then
+	CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
+	export CONFIG_SHELL
+	SHELL="$CONFIG_SHELL"
+	export SHELL
+	echo="$CONFIG_SHELL [$]0 --fallback-echo"
+      elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
+	   test "X$echo_testing_string" = 'X\t' &&
+	   echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
+	   test "X$echo_testing_string" = "X$echo_test_string"; then
+	echo="$CONFIG_SHELL [$]0 --fallback-echo"
+      else
+	# maybe with a smaller string...
+	prev=:
+
+	for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do
+	  if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null
+	  then
+	    break
+	  fi
+	  prev="$cmd"
+	done
+
+	if test "$prev" != 'sed 50q "[$]0"'; then
+	  echo_test_string=`eval $prev`
+	  export echo_test_string
+	  exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}
+	else
+	  # Oops.  We lost completely, so just stick with echo.
+	  echo=echo
+	fi
+      fi
+    fi
+  fi
+fi
+fi
+
+# Copy echo and quote the copy suitably for passing to libtool from
+# the Makefile, instead of quoting the original, which is used later.
+ECHO=$echo
+if test "X$ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then
+   ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"
+fi
+
+AC_SUBST(ECHO)
+])
+_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
+_LT_DECL([], [echo], [1],
+    [An echo program that does not interpret backslashes])
+])# _LT_AC_PROG_ECHO_BACKSLASH
+
+
+# _LT_AC_LOCK
+# -----------
+AC_DEFUN([_LT_AC_LOCK],
+[AC_REQUIRE([AC_OBJEXT])dnl
+AC_ARG_ENABLE([libtool-lock],
+    [AC_HELP_STRING([--disable-libtool-lock],
+	[avoid locking (might break parallel builds)])])
+test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *ELF-32*)
+      HPUX_IA64_MODE="32"
+      ;;
+    *ELF-64*)
+      HPUX_IA64_MODE="64"
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out which ABI we are using.
+  echo '[#]line __oline__ "configure"' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+   if test "$lt_cv_prog_gnu_ld" = yes; then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -melf32bsmip"
+      ;;
+    *N32*)
+      LD="${LD-ld} -melf32bmipn32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -melf64bmip"
+      ;;
+    esac
+   else
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -32"
+      ;;
+    *N32*)
+      LD="${LD-ld} -n32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -64"
+      ;;
+    esac
+   fi
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if AC_TRY_EVAL(ac_compile); then
+    case "`/usr/bin/file conftest.o`" in
+    *32-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_i386"
+          ;;
+        ppc64-*linux*|powerpc64-*linux*)
+          LD="${LD-ld} -m elf32ppclinux"
+          ;;
+        s390x-*linux*)
+          LD="${LD-ld} -m elf_s390"
+          ;;
+        sparc64-*linux*)
+          LD="${LD-ld} -m elf32_sparc"
+          ;;
+      esac
+      ;;
+    *64-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        ppc*-*linux*|powerpc*-*linux*)
+          LD="${LD-ld} -m elf64ppc"
+          ;;
+        s390*-*linux*)
+          LD="${LD-ld} -m elf64_s390"
+          ;;
+        sparc*-*linux*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS -belf"
+  AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
+    [AC_LANG_PUSH(C)
+     AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
+     AC_LANG_POP])
+  if test x"$lt_cv_cc_needs_belf" != x"yes"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS="$SAVE_CFLAGS"
+  fi
+  ;;
+esac
+
+need_locks="$enable_libtool_lock"
+])# _LT_AC_LOCK
+
+
+# AC_LIBTOOL_SYS_OLD_ARCHIVE
+# --------------------------
+AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE],
+[AC_CHECK_TOOL(AR, ar, false)
+test -z "$AR" && AR=ar
+test -z "$AR_FLAGS" && AR_FLAGS=cru
+_LT_DECL([], [AR], [1], [The archiver])
+_LT_DECL([], [AR_FLAGS], [1])
+
+AC_CHECK_TOOL(STRIP, strip, :)
+test -z "$STRIP" && STRIP=:
+_LT_DECL([], [STRIP], [1], [A symbol stripping program])
+
+AC_CHECK_TOOL(RANLIB, ranlib, :)
+test -z "$RANLIB" && RANLIB=:
+_LT_DECL([], [RANLIB], [1],
+    [Commands used to install an old-style archive])
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  openbsd*)
+    old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds"
+    ;;
+  *)
+    old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
+fi
+_LT_DECL([], [old_postinstall_cmds], [2])
+_LT_DECL([], [old_postuninstall_cmds], [2])
+_LT_TAGDECL([], [old_archive_cmds], [2],
+    [Commands used to build an old-style archive])
+])# AC_LIBTOOL_SYS_OLD_ARCHIVE
+
+
+# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
+# ----------------------------------------------------------------
+# Check whether the given compiler option works
+AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],
+[AC_REQUIRE([AC_OBJEXT])dnl
+AC_REQUIRE([LT_AC_PROG_SED])dnl
+AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+  m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$3"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test ! -s conftest.err; then
+       $2=yes
+     fi
+   fi
+   $rm conftest*
+])
+
+if test x"[$]$2" = xyes; then
+    m4_if([$5], , :, [$5])
+else
+    m4_if([$6], , :, [$6])
+fi
+])# AC_LIBTOOL_COMPILER_OPTION
+
+
+# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
+#                          [ACTION-SUCCESS], [ACTION-FAILURE])
+# ------------------------------------------------------------
+# Check whether the given compiler option works
+m4_define([AC_LIBTOOL_LINKER_OPTION],
+[AC_CACHE_CHECK([$1], [$2],
+  [$2=no
+   save_LDFLAGS="$LDFLAGS"
+   LDFLAGS="$LDFLAGS $3"
+   printf "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&AS_MESSAGE_LOG_FD
+     else
+       $2=yes
+     fi
+   fi
+   $rm conftest*
+   LDFLAGS="$save_LDFLAGS"
+])
+
+if test x"[$]$2" = xyes; then
+    m4_if([$4], , :, [$4])
+else
+    m4_if([$5], , :, [$5])
+fi
+])# AC_LIBTOOL_LINKER_OPTION
+
+
+# AC_LIBTOOL_SYS_MAX_CMD_LEN
+# --------------------------
+AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+# find the maximum length of command line arguments
+AC_MSG_CHECKING([the maximum length of command line arguments])
+AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
+  i=0
+  teststring="ABCD"
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+ *)
+    # Make teststring a little bigger before we do anything with it.
+    # a 1K string should be a reasonable start.
+    for i in 1 2 3 4 5 6 7 8 ; do
+      teststring=$teststring$teststring
+    done
+    # If test is not a shell built-in, we'll probably end up computing a
+    # maximum length that is only half of the actual maximum length, but
+    # we can't tell.
+    while (test "X"`$CONFIG_SHELL [$]0 --fallback-echo "X$teststring$teststring" 2>/dev/null` \
+	       = "XX$teststring$teststring") >/dev/null 2>&1 &&
+	    test $i != 17 # 1/2 MB should be enough
+    do
+      i=`expr $i + 1`
+      teststring=$teststring$teststring
+    done
+    # Only check the string length outside the loop.
+    lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+    teststring=
+    # Add a significant safety factor because C++ compilers can tack on massive
+    # amounts of additional arguments before passing them to the linker.
+    # It appears as though 1/2 is a usable value.
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    ;;
+  esac
+])
+if test -n $lt_cv_sys_max_cmd_len ; then
+  AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
+else
+  AC_MSG_RESULT(none)
+fi
+_LT_DECL([max_cmd_len], [lt_cv_sys_max_cmd_len], [0],
+    [What is the maximum length of a command?])
+])# AC_LIBTOOL_SYS_MAX_CMD_LEN
+
+
+# _LT_AC_CHECK_DLFCN
+# --------------------
+AC_DEFUN([_LT_AC_CHECK_DLFCN],
+[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
+])# _LT_AC_CHECK_DLFCN
+
+
+# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
+#                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
+# ------------------------------------------------------------------
+AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],
+[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
+if test "$cross_compiling" = yes; then :
+  [$4]
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+[#line __oline__ "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef __cplusplus
+extern "C" void exit (int);
+#endif
+
+void fnord() { int i=42;}
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
+      /* dlclose (self); */
+    }
+
+    exit (status);
+}]
+_LT_EOF
+  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
+    (./conftest; exit; ) 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) $1 ;;
+      x$lt_dlneed_uscore) $2 ;;
+      x$lt_unknown|x*) $3 ;;
+    esac
+  else :
+    # compilation failed
+    $3
+  fi
+fi
+rm -fr conftest*
+])# _LT_AC_TRY_DLOPEN_SELF
+
+
+# AC_LIBTOOL_DLOPEN_SELF
+# -------------------
+AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],
+[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
+if test "x$enable_dlopen" != xyes; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen="load_add_on"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32*)
+    lt_cv_dlopen="LoadLibrary"
+    lt_cv_dlopen_libs=
+   ;;
+
+  cygwin*)
+    lt_cv_dlopen="dlopen"
+    lt_cv_dlopen_libs=
+   ;;
+
+  darwin*)
+  # if libdl is installed we need to link against it
+    AC_CHECK_LIB([dl], [dlopen],
+		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
+    lt_cv_dlopen="dyld"
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ])
+   ;;
+
+  *)
+    AC_CHECK_FUNC([shl_load],
+	  [lt_cv_dlopen="shl_load"],
+      [AC_CHECK_LIB([dld], [shl_load],
+	    [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],
+	[AC_CHECK_FUNC([dlopen],
+	      [lt_cv_dlopen="dlopen"],
+	  [AC_CHECK_LIB([dl], [dlopen],
+		[lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
+	    [AC_CHECK_LIB([svld], [dlopen],
+		  [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
+	      [AC_CHECK_LIB([dld], [dld_link],
+		    [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])
+	      ])
+	    ])
+	  ])
+	])
+      ])
+    ;;
+  esac
+
+  if test "x$lt_cv_dlopen" != xno; then
+    enable_dlopen=yes
+  else
+    enable_dlopen=no
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS="$CPPFLAGS"
+    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS="$LDFLAGS"
+    eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS="$LIBS"
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    AC_CACHE_CHECK([whether a program can dlopen itself],
+	  lt_cv_dlopen_self, [dnl
+	  _LT_AC_TRY_DLOPEN_SELF(
+	    lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
+	    lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
+    ])
+
+    if test "x$lt_cv_dlopen_self" = xyes; then
+      LDFLAGS="$LDFLAGS $link_static_flag"
+      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
+    	  lt_cv_dlopen_self_static, [dnl
+	  _LT_AC_TRY_DLOPEN_SELF(
+	    lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
+	    lt_cv_dlopen_self_static=no,  lt_cv_dlopen_self_static=cross)
+      ])
+    fi
+
+    CPPFLAGS="$save_CPPFLAGS"
+    LDFLAGS="$save_LDFLAGS"
+    LIBS="$save_LIBS"
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+_LT_DECL([dlopen_support], [enable_dlopen], [0],
+	 [Whether dlopen is supported])
+_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
+	 [Whether dlopen of programs is supported])
+_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
+	 [Whether dlopen of statically linked programs is supported])
+])# AC_LIBTOOL_DLOPEN_SELF
+
+
+# AC_LIBTOOL_PROG_CC_C_O([TAGNAME])
+# ---------------------------------
+# Check to see if options -c and -o are simultaneously supported by compiler
+AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],
+[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
+AC_REQUIRE([AC_OBJEXT])dnl
+AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
+  [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
+  [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
+   $rm -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
+   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&AS_MESSAGE_LOG_FD
+   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test ! -s out/conftest.err; then
+       _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+     fi
+   fi
+   chmod u+w .
+   $rm conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
+   $rm out/* && rmdir out
+   cd ..
+   rmdir conftest
+   $rm conftest*
+])
+_LT_DECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
+	[Does compiler simultaneously support -c and -o options?])
+])# AC_LIBTOOL_PROG_CC_C_O
+
+
+# AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME])
+# -----------------------------------------
+# Check to see if we can do hard links to lock some files if needed
+AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS],
+[AC_REQUIRE([AC_LIBTOOL_PROG_CC_C_O])dnl
+AC_REQUIRE([_LT_AC_LOCK])dnl
+
+hard_links="nottested"
+if test "$_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
+  # do not overwrite the value of need_locks provided by the user
+  AC_MSG_CHECKING([if we can lock with hard links])
+  hard_links=yes
+  $rm conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  AC_MSG_RESULT([$hard_links])
+  if test "$hard_links" = no; then
+    AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
+])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS
+
+
+# AC_LIBTOOL_OBJDIR
+# -----------------
+AC_DEFUN([AC_LIBTOOL_OBJDIR],
+[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
+[rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null])
+objdir=$lt_cv_objdir
+_LT_DECL([], [objdir], [0],
+         [The name of the directory that contains temporary libtool files])dnl
+])# AC_LIBTOOL_OBJDIR
+
+
+# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME])
+# ----------------------------------------------
+# Check hardcoding attributes.
+AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH],
+[AC_MSG_CHECKING([how to hardcode library paths into programs])
+_LT_AC_TAGVAR(hardcode_action, $1)=
+if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
+   test -n "$_LT_AC_TAGVAR(runpath_var $1)" ||
+   test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)"="Xyes" ; then
+
+  # We can hardcode non-existant directories.
+  if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
+     test "$_LT_AC_TAGVAR(hardcode_minus_L, $1)" != no; then
+    # Linking always hardcodes the temporary library directory.
+    _LT_AC_TAGVAR(hardcode_action, $1)=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    _LT_AC_TAGVAR(hardcode_action, $1)=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  _LT_AC_TAGVAR(hardcode_action, $1)=unsupported
+fi
+AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)])
+
+if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink ||
+   test "$_LT_AC_TAGVAR(inherit_rpath, $1)" = yes; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test "$shlibpath_overrides_runpath" = yes ||
+     test "$enable_shared" = no; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+_LT_TAGDECL([], [hardcode_action], [0],
+    [How to hardcode a shared library path into an executable])
+])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH
+
+
+# AC_LIBTOOL_SYS_LIB_STRIP
+# ------------------------
+AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP],
+[AC_REQUIRE([LT_AC_PROG_EGREP])
+striplib=
+old_striplib=
+AC_MSG_CHECKING([whether stripping libraries is possible])
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  AC_MSG_RESULT([yes])
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+   darwin*)
+       if test -n "$STRIP" ; then
+         striplib="$STRIP -x"
+         AC_MSG_RESULT([yes])
+       else
+  AC_MSG_RESULT([no])
+fi
+       ;;
+   *)
+  AC_MSG_RESULT([no])
+    ;;
+  esac
+fi
+_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
+_LT_DECL([], [striplib], [1])
+])# AC_LIBTOOL_SYS_LIB_STRIP
+
+
+# AC_LIBTOOL_SYS_DYNAMIC_LINKER
+# -----------------------------
+# PORTME Fill in your ld.so characteristics
+AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER],
+[AC_REQUIRE([LT_AC_PROG_EGREP])
+AC_MSG_CHECKING([dynamic linker characteristics])
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=".so"
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+if test "$GCC" = yes; then
+  sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+  if echo "$sys_lib_search_path_spec" | $GREP ';' >/dev/null ; then
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+  else
+    sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+  fi
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+case $host_os in
+aix3*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='${libname}${release}${shared_ext}$major'
+  ;;
+
+aix4* | aix5*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test "$host_cpu" = ia64; then
+    # AIX 5 supports IA64
+    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line `#! .'.  This would cause the generated library to
+    # depend on `.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.[[01]] | aix4.[[01]].*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    if test "$aix_use_runtimelinking" = yes; then
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    else
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='${libname}${release}.a $libname.a'
+      soname_spec='${libname}${release}${shared_ext}$major'
+    fi
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  if test "$host_cpu" = m68k; then
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+  else
+    dynamic_linker=no
+  fi
+  ;;
+
+beos*)
+  library_names_spec='${libname}${shared_ext}'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi4*)
+  version_type=linux
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32*)
+  version_type=windows
+  shrext_cmds=".dll"
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$host_os in
+  yes,cygwin* | yes,mingw* | yes,pw32*)
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \${file}`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $rm \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
+      ;;
+    mingw*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
+      sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
+      if echo "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
+        # It is most probably a Windows format PATH printed by
+        # mingw gcc, but we are running on Cygwin. Gcc prints its search
+        # path with ; separators, and with drive letters. We can handle the
+        # drive letters (cygwin fileutils understands them), so leave them,
+        # especially as we might pass files found there to a mingw objdump,
+        # which wouldn't understand a cygwinified path. Ahh.
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
+      ;;
+    esac
+    ;;
+
+  *)
+    library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
+    ;;
+  esac
+  dynamic_linker='Win32 ld.exe'
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
+  soname_spec='${libname}${release}${major}$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)'
+  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
+  if test "$GCC" = yes; then
+    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | $GREP "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
+  else
+    sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
+  fi
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd1*)
+  dynamic_linker=no
+  ;;
+
+kfreebsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+freebsd*)
+  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.[01]* | freebsdelf3.[01]*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  *) # from 3.2 on
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+gnu*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case "$host_cpu" in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    if test "X$HPUX_IA64_MODE" = X32; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+    fi
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+   hppa*64*)
+     shrext_cmds='.sl'
+     hardcode_into_libs=yes
+     dynamic_linker="$host_os dld.sl"
+     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+     shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+     library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+     soname_spec='${libname}${release}${shared_ext}$major'
+     sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+     ;;
+   *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555.
+  postinstall_cmds='chmod 555 $lib'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test "$lt_cv_prog_gnu_ld" = yes; then
+		version_type=linux
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
+  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Append ld.so.conf contents to the search path
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`$SED -e 's/[:,\t]/ /g;s/=[^=]*$//;s/=[^= ]* / /g' /etc/ld.so.conf | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+knetbsd*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='GNU ld.so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+    soname_spec='${libname}${release}${shared_ext}$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+nto-qnx*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+openbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=yes
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    case $host_os in
+      openbsd2.[[89]] | openbsd2.[[89]].*)
+	shlibpath_overrides_runpath=no
+	;;
+      *)
+	shlibpath_overrides_runpath=yes
+	;;
+      esac
+  else
+    shlibpath_overrides_runpath=yes
+  fi
+  ;;
+
+os2*)
+  libname_spec='$name'
+  shrext_cmds=".dll"
+  need_lib_prefix=no
+  library_names_spec='$libname${shared_ext} $libname.a'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=LIBPATH
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
+  ;;
+
+sco3.2v5*)
+  version_type=osf
+  soname_spec='${libname}${release}${shared_ext}$major'
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+solaris*)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test "$with_gnu_ld" = yes; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec ;then
+    version_type=linux
+    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
+    soname_spec='$libname${shared_ext}.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+uts4*)
+  version_type=linux
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+AC_MSG_RESULT([$dynamic_linker])
+test "$dynamic_linker" = no && can_build_shared=no
+_LT_DECL([], [need_lib_prefix], [0],
+    [Do we need the "lib" prefix for modules?])
+_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
+_LT_DECL([], [version_type], [0], [Library versioning type])
+_LT_DECL([], [runpath_var], [0],  [Shared library runtime path variable])
+_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
+_LT_DECL([], [shlibpath_overrides_runpath], [0],
+    [Is shibpath searched before the hard-coded library search path?])
+_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
+_LT_DECL([], [library_names_spec], [1],
+    [List of archive names.  First name is the real one, the rest are links.
+    The last name is the one that the linker finds with -lNAME])
+_LT_DECL([], [soname_spec], [1],
+    [The coded name of the library, if different from the real name])
+_LT_DECL([], [postinstall_cmds], [2],
+    [Command to use after installation of a shared archive])
+_LT_DECL([], [postuninstall_cmds], [2],
+    [Command to use after uninstallation of a shared archive])
+_LT_DECL([], [finish_cmds], [2],
+    [Commands used to finish a libtool library installation in a directory])
+_LT_DECL([], [finish_eval], [1],
+    [As "finish_cmds", except a single script fragment to be evaled but
+    not shown])
+_LT_DECL([], [hardcode_into_libs], [0],
+    [Whether we should hardcode library paths into libraries])
+_LT_DECL([], [sys_lib_search_path_spec], [2],
+    [Compile-time system search path for libraries])
+_LT_DECL([], [sys_lib_dlsearch_path_spec], [2],
+    [Run-time system search path for libraries])
+])# AC_LIBTOOL_SYS_DYNAMIC_LINKER
+
+
+# AC_PATH_TOOL_PREFIX
+# -------------------
+# find a file program which can recognise shared library
+AC_DEFUN([AC_PATH_TOOL_PREFIX],
+[AC_REQUIRE([LT_AC_PROG_EGREP])dnl
+AC_MSG_CHECKING([for $1])
+AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
+[case $MAGIC_CMD in
+[[\\/*] |  ?:[\\/]*])
+  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD="$MAGIC_CMD"
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+dnl $ac_dummy forces splitting on constant user-supplied paths.
+dnl POSIX.2 word splitting is done only on the output of word expansions,
+dnl not every word.  This closes a longstanding sh security hole.
+  ac_dummy="m4_if([$2], , $PATH, [$2])"
+  for ac_dir in $ac_dummy; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$1; then
+      lt_cv_path_MAGIC_CMD="$ac_dir/$1"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
+	  MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS="$lt_save_ifs"
+  MAGIC_CMD="$lt_save_MAGIC_CMD"
+  ;;
+esac])
+MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
+if test -n "$MAGIC_CMD"; then
+  AC_MSG_RESULT($MAGIC_CMD)
+else
+  AC_MSG_RESULT(no)
+fi
+_LT_DECL([], [MAGIC_CMD], [0],
+	 [Used to examine libraries when file_magic_cmd begins "file"])dnl
+])# AC_PATH_TOOL_PREFIX
+
+
+# AC_PATH_MAGIC
+# -------------
+# find a file program which can recognise a shared library
+AC_DEFUN([AC_PATH_MAGIC],
+[AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    AC_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
+  else
+    MAGIC_CMD=:
+  fi
+fi
+])# AC_PATH_MAGIC
+
+
+# AC_PROG_LD
+# ----------
+# find the pathname to the GNU or non-GNU linker
+AC_DEFUN([AC_PROG_LD],
+[AC_ARG_WITH([gnu-ld],
+    [AC_HELP_STRING([--with-gnu-ld],
+	[assume the C compiler uses GNU ld @<:@default=no@:>@])],
+    [test "$withval" = no || with_gnu_ld=yes],
+    [with_gnu_ld=no])
+AC_REQUIRE([LT_AC_PROG_SED])dnl
+AC_REQUIRE([LT_AC_PROG_EGREP])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([AC_CANONICAL_BUILD])dnl
+
+ac_prog=ld
+if test "$GCC" = yes; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  AC_MSG_CHECKING([for ld used by $CC])
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    [[\\/]]* | ?:[[\\/]]*)
+      re_direlt='/[[^/]][[^/]]*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
+      while echo $ac_prog | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD="$ac_prog"
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test "$with_gnu_ld" = yes; then
+  AC_MSG_CHECKING([for GNU ld])
+else
+  AC_MSG_CHECKING([for non-GNU ld])
+fi
+AC_CACHE_VAL(lt_cv_path_LD,
+[if test -z "$LD"; then
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD="$ac_dir/$ac_prog"
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some GNU ld's only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test "$with_gnu_ld" != no && break
+	;;
+      *)
+	test "$with_gnu_ld" != yes && break
+	;;
+      esac
+    fi
+  done
+  IFS="$lt_save_ifs"
+else
+  lt_cv_path_LD="$LD" # Let the user override the test with a path.
+fi])
+LD="$lt_cv_path_LD"
+if test -n "$LD"; then
+  AC_MSG_RESULT($LD)
+else
+  AC_MSG_RESULT(no)
+fi
+test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
+AC_PROG_LD_GNU
+AC_SUBST([LD])
+
+_LT_TAGDECL([], [LD], [1], [The linker used to build libraries])
+])# AC_PROG_LD
+
+# Old name:
+AU_DEFUN([AM_PROG_LD], [AC_PROG_LD])
+
+
+# AC_PROG_LD_GNU
+# --------------
+AC_DEFUN([AC_PROG_LD_GNU],
+[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
+[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac])
+with_gnu_ld=$lt_cv_prog_gnu_ld
+])# AC_PROG_LD_GNU
+
+
+# AC_PROG_LD_RELOAD_FLAG
+# ----------------------
+# find reload flag for linker
+#   -- PORTME Some linkers may need a different reload flag.
+AC_DEFUN([AC_PROG_LD_RELOAD_FLAG],
+[AC_CACHE_CHECK([for $LD option to reload object files],
+  lt_cv_ld_reload_flag,
+  [lt_cv_ld_reload_flag='-r'])
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  darwin*)
+    if test "$GCC" = yes; then
+      reload_cmds='$CC -nostdlib ${wl}-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'   
+    fi
+    ;;
+esac
+_LT_DECL([], [reload_flag], [1], [How to create reloadable object files])dnl
+_LT_DECL([], [reload_cmds], [2])dnl
+])# AC_PROG_LD_RELOAD_FLAG
+
+
+# AC_DEPLIBS_CHECK_METHOD
+# -----------------------
+# how to check for library dependencies
+#  -- PORTME fill in with the dynamic library characteristics
+AC_DEFUN([AC_DEPLIBS_CHECK_METHOD],
+[AC_REQUIRE([LT_AC_PROG_EGREP])
+AC_CACHE_CHECK([how to recognise dependent libraries],
+lt_cv_deplibs_check_method,
+[lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# `unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic [[regex]]' -- check by looking for files in library path
+# which responds to the $file_magic_cmd with a given extended regex.
+# If you have `file' or equivalent on your system and you're not sure
+# whether `pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix4* | aix5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi4*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump'.
+mingw* | pw32*)
+  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | kfreebsd*-gnu)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[[3-9]]86 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case "$host_cpu" in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be Linux ELF.
+linux*)
+  case $host_cpu in
+  alpha*|hppa*|i*86|ia64*|m68*|mips*|powerpc*|sparc*|s390*|sh*)
+    lt_cv_deplibs_check_method=pass_all ;;
+  *)
+    # glibc up to 2.1.1 does not perform some relocations on ARM
+    # this will be overridden with pass_all, but let us keep it just in case
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;;
+  esac
+  lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd* | knetbsd*-gnu)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+nto-qnx*)
+  lt_cv_deplibs_check_method=unknown
+  ;;
+
+openbsd*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object'
+  else
+    lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sco3.2v5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+])
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+_LT_DECL([], [deplibs_check_method], [1],
+    [Method to check whether dependent libraries are shared objects])
+_LT_DECL([], [file_magic_cmd], [1],
+    [Command to use when deplibs_check_method == "file_magic"])
+])# AC_DEPLIBS_CHECK_METHOD
+
+
+# AC_PROG_NM
+# ----------
+# find the pathname to a BSD-compatible name lister
+AC_DEFUN([AC_PROG_NM],
+[AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM,
+[if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM="$NM"
+else
+  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
+    IFS="$lt_save_ifs"
+    test -z "$ac_dir" && ac_dir=.
+    tmp_nm="$ac_dir/${ac_tool_prefix}nm"
+    if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
+      # Check to see if the nm accepts a BSD-compat flag.
+      # Adding the `sed 1q' prevents false positives on HP-UX, which says:
+      #   nm: unknown option "B" ignored
+      # Tru64's nm complains that /dev/null is an invalid object file
+      case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
+      */dev/null* | *'Invalid file or object type'*)
+	lt_cv_path_NM="$tmp_nm -B"
+	break
+        ;;
+      *)
+	case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	*/dev/null*)
+	  lt_cv_path_NM="$tmp_nm -p"
+	  break
+	  ;;
+	*)
+	  lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	  continue # so that we can try to find one that supports BSD flags
+	  ;;
+	esac
+      esac
+    fi
+  done
+  IFS="$lt_save_ifs"
+  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
+fi])
+NM="$lt_cv_path_NM"
+test -z "$NM" && NM=nm
+AC_SUBST([NM])
+_LT_DECL([], [NM], [1], [A BSD-compatible nm program])dnl
+])# AC_PROG_NM
+
+# Old name:
+AU_DEFUN([AM_PROG_NM], [AC_PROG_NM])
+
+
+# AC_CHECK_LIBM
+# -------------
+# check for math library
+AC_DEFUN([AC_CHECK_LIBM],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+LIBM=
+case $host in
+*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)
+  # These system don't have libm, or don't need it
+  ;;
+*-ncr-sysv4.3*)
+  AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
+  AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
+  ;;
+*)
+  AC_CHECK_LIB(m, cos, LIBM="-lm")
+  ;;
+esac
+])# AC_CHECK_LIBM
+
+
+# AC_LIBLTDL_CONVENIENCE([DIRECTORY])
+# -----------------------------------
+# sets LIBLTDL to the link flags for the libltdl convenience library and
+# LTDLINCL to the include flags for the libltdl header and adds
+# --enable-ltdl-convenience to the configure arguments.  Note that LIBLTDL
+# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called.  If
+# DIRECTORY is not provided, it is assumed to be `libltdl'.  LIBLTDL will
+# be prefixed with '${top_builddir}/' and LTDLINCL will be prefixed with
+# '${top_srcdir}/' (note the single quotes!).  If your package is not
+# flat and you're not using automake, define top_builddir and
+# top_srcdir appropriately in the Makefiles.
+AC_DEFUN([AC_LIBLTDL_CONVENIENCE],
+[case $enable_ltdl_convenience in
+  no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
+  "") enable_ltdl_convenience=yes
+      ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
+  esac
+  LIBLTDL='${top_builddir}/'m4_if($#, 1,[$1], ['libltdl'])/libltdlc.la
+  LTDLINCL='-I${top_srcdir}/'m4_if($#, 1, [$1], ['libltdl'])
+  # For backwards non-gettext consistent compatibility...
+  INCLTDL="$LTDLINCL"
+])# AC_LIBLTDL_CONVENIENCE
+
+
+# AC_LIBLTDL_INSTALLABLE([DIRECTORY])
+# -----------------------------------
+# sets LIBLTDL to the link flags for the libltdl installable library and
+# LTDLINCL to the include flags for the libltdl header and adds
+# --enable-ltdl-install to the configure arguments.  Note that LIBLTDL
+# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called.  If
+# DIRECTORY is not provided and an installed libltdl is not found, it is
+# assumed to be `libltdl'.  LIBLTDL will be prefixed with '${top_builddir}/'
+# and LTDLINCL will be prefixed with '${top_srcdir}/' (note the single
+# quotes!).  If your package is not flat and you're not using automake,
+# define top_builddir and top_srcdir appropriately in the Makefiles.
+# In the future, this macro may have to be called after AC_PROG_LIBTOOL.
+AC_DEFUN([AC_LIBLTDL_INSTALLABLE],
+[AC_CHECK_LIB(ltdl, lt_dlinit,
+  [test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],
+  [if test x"$enable_ltdl_install" = xno; then
+     AC_MSG_WARN([libltdl not installed, but installation disabled])
+   else
+     enable_ltdl_install=yes
+   fi
+  ])
+  if test x"$enable_ltdl_install" = x"yes"; then
+    ac_configure_args="$ac_configure_args --enable-ltdl-install"
+    LIBLTDL='${top_builddir}/'m4_if($#, 1, [$1], ['libltdl'])/libltdl.la
+    LTDLINCL='-I${top_srcdir}/'m4_if($#, 1, [$1], ['libltdl'])
+  else
+    ac_configure_args="$ac_configure_args --enable-ltdl-install=no"
+    LIBLTDL="-lltdl"
+    LTDLINCL=
+  fi
+  # For backwards non-gettext consistent compatibility...
+  INCLTDL="$LTDLINCL"
+])# AC_LIBLTDL_INSTALLABLE
+
+
+# AC_LIBTOOL_PROG_COMPILER_NO_RTTI([TAGNAME])
+# -------------------------------------------
+AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI],
+[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
+
+_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+
+if test "$GCC" = yes; then
+  _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+
+  AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
+    lt_cv_prog_compiler_rtti_exceptions,
+    [-fno-rtti -fno-exceptions], [],
+    [_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
+fi
+_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
+	[Compiler flag to turn off builtin functions])
+])# AC_LIBTOOL_PROG_COMPILER_NO_RTTI
+
+
+# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
+# ---------------------------------
+AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],
+[AC_REQUIRE([AC_CANONICAL_HOST])dnl
+AC_REQUIRE([LT_AC_PROG_EGREP])dnl
+AC_REQUIRE([AC_PROG_CC])dnl
+AC_REQUIRE([AC_PROG_LD])dnl
+AC_REQUIRE([AC_PROG_NM])dnl
+AC_REQUIRE([AC_OBJEXT])dnl
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+AC_MSG_CHECKING([command to parse $NM output from $compiler object])
+AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
+[
+# These are sane defaults that work on at least a few old systems.
+# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
+
+# Character class describing NM global symbol codes.
+symcode='[[BCDEGRST]]'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
+
+# Transform the above into a raw symbol and a C symbol.
+symxfrm='\1 \2\3 \3'
+
+# Transform an extracted symbol line into a proper C declaration
+lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='[[BCDT]]'
+  ;;
+cygwin* | mingw* | pw32*)
+  symcode='[[ABCDGISTW]]'
+  ;;
+hpux*) # Its linker distinguishes data from code symbols
+  if test "$host_cpu" = ia64; then
+    symcode='[[ABCDEGRST]]'
+  fi
+  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
+  lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
+  ;;
+irix* | nonstopux*)
+  symcode='[[BCDEGRST]]'
+  ;;
+osf*)
+  symcode='[[BCDEGQRST]]'
+  ;;
+solaris* | sysv5*)
+  symcode='[[BDRT]]'
+  ;;
+sysv4)
+  symcode='[[DFNSTU]]'
+  ;;
+esac
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='[[ABCDGIRSTW]]' ;;
+esac
+
+# Try without a prefix undercore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Write the raw and C identifiers.
+  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ 	]]\($symcode$symcode*\)[[ 	]][[ 	]]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+  if AC_TRY_EVAL(ac_compile); then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<_LT_EOF > conftest.$ac_ext
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+	  cat <<_LT_EOF >> conftest.$ac_ext
+#if defined (__STDC__) && __STDC__
+# define lt_ptr_t void *
+#else
+# define lt_ptr_t char *
+# define const
+#endif
+
+/* The mapping between symbol names and symbols. */
+const struct {
+  const char *name;
+  lt_ptr_t address;
+}
+lt_preloaded_symbols[[]] =
+{
+_LT_EOF
+	  $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  cat <<\_LT_EOF >> conftest.$ac_ext
+  {0, (lt_ptr_t) 0}
+};
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_save_LIBS="$LIBS"
+	  lt_save_CFLAGS="$CFLAGS"
+	  LIBS="conftstm.$ac_objext"
+	  CFLAGS="$CFLAGS$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
+	  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
+	    pipe_works=yes
+	  fi
+	  LIBS="$lt_save_LIBS"
+	  CFLAGS="$lt_save_CFLAGS"
+	else
+	  echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
+    fi
+  else
+    echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
+    cat conftest.$ac_ext >&5
+  fi
+  rm -f conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test "$pipe_works" = yes; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+])
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  AC_MSG_RESULT(failed)
+else
+  AC_MSG_RESULT(ok)
+fi
+
+_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
+    [Take the output of nm and produce a listing of raw symbols and C names])
+_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
+    [Transform the output of nm in a proper C declaration])
+_LT_DECL([global_symbol_to_c_name_address],
+    [lt_cv_sys_global_symbol_to_c_name_address], [1],
+    [Transform the output of nm in a C name address pair])
+]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
+
+
+# AC_LIBTOOL_PROG_COMPILER_PIC([TAGNAME])
+# ---------------------------------------
+AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC],
+[_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)=
+_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=
+
+AC_MSG_CHECKING([for $compiler option to produce PIC])
+m4_if([$1], [CXX], [
+  # C++ specific cases for pic, static, wl, etc.
+  if test "$GXX" = yes; then
+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+    aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+    amigaos*)
+      if test "$host_cpu" = m68k; then
+        # FIXME: we need at least 68020 code to build shared libraries, but
+        # adding the `-m68020' flag to GCC prevents building anything better,
+        # like `-m68040'.
+        _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+      fi
+      ;;
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+    mingw* | os2* | pw32*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
+      ;;
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+    *djgpp*)
+      # DJGPP does not support shared libraries at all
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case "$host_cpu" in
+      hppa*64*|ia64*)
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	;;
+      esac
+      ;;
+    *)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+  else
+    case $host_os in
+      aix4* | aix5*)
+	# All AIX code is PIC.
+	if test "$host_cpu" = ia64; then
+	  # AIX 5 now supports IA64 processor
+	  _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	else
+	  _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+	fi
+	;;
+      chorus*)
+	case $cc_basename in
+	cxch68)
+	  # Green Hills C++ Compiler
+	  # _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+	  ;;
+	esac
+	;;
+       darwin*)
+         # PIC is the default on this platform
+         # Common symbols not allowed in MH_DYLIB files
+         case "$cc_basename" in
+           xlc*)
+           _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
+           _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+           ;;
+         esac
+       ;;
+      dgux*)
+	case $cc_basename in
+	  ec++)
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    ;;
+	  ghcx)
+	    # Green Hills C++ Compiler
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      freebsd* | kfreebsd*-gnu)
+	# FreeBSD uses GNU C++
+	;;
+      hpux9* | hpux10* | hpux11*)
+	case $cc_basename in
+	  CC)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"
+	    if test "$host_cpu" != ia64; then
+	      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	    fi
+	    ;;
+	  aCC)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"
+	    case "$host_cpu" in
+	    hppa*64*|ia64*)
+	      # +Z the default
+	      ;;
+	    *)
+	      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	      ;;
+	    esac
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      irix5* | irix6* | nonstopux*)
+	case $cc_basename in
+	  CC)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    # CC pic flag -KPIC is the default.
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      linux*)
+	case $cc_basename in
+	  KCC)
+	    # KAI C++ Compiler
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	    ;;
+	  icpc)
+	    # Intel C++
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+	    ;;
+	  cxx)
+	    # Compaq C++
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      lynxos*)
+	;;
+      m88k*)
+	;;
+      mvs*)
+	case $cc_basename in
+	  cxx)
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      netbsd*)
+	;;
+      osf3* | osf4* | osf5*)
+	case $cc_basename in
+	  KCC)
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
+	    ;;
+	  RCC)
+	    # Rational C++ 2.4.1
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  cxx)
+	    # Digital/Compaq C++
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      psos*)
+	;;
+      sco*)
+	case $cc_basename in
+	  CC)
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      solaris*)
+	case $cc_basename in
+	  CC)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+	    ;;
+	  gcx)
+	    # Green Hills C++ Compiler
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sunos4*)
+	case $cc_basename in
+	  CC)
+	    # Sun C++ 4.x
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+	    ;;
+	  lcc)
+	    # Lucid
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      tandem*)
+	case $cc_basename in
+	  NCC)
+	    # NonStop-UX NCC 3.20
+	    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      unixware*)
+	;;
+      vxworks*)
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+	;;
+    esac
+  fi
+],
+[
+  if test "$GCC" = yes; then
+    _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+    _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    amigaos*)
+      if test "$host_cpu" = m68k; then
+        # FIXME: we need at least 68020 code to build shared libraries, but
+        # adding the `-m68020' flag to GCC prevents building anything better,
+        # like `-m68040'.
+        _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
+      fi
+      ;;
+
+    beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      enable_shared=no
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
+      fi
+      ;;
+
+    hpux*)
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case "$host_cpu" in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	;;
+      esac
+      ;;
+
+    *)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      if test "$host_cpu" = ia64; then
+	# AIX 5 now supports IA64 processor
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      else
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+      darwin*)
+        # PIC is the default on this platform
+        # Common symbols not allowed in MH_DYLIB files
+       case "$cc_basename" in
+         xlc*)
+         _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
+         _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+         ;;
+       esac
+       ;;
+
+    mingw* | pw32* | os2*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case "$host_cpu" in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # PIC (with -KPIC) is the default.
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    newsos6)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    linux*)
+      case $CC in
+      icc* | ecc*)
+	_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
+        ;;
+      ccc*)
+        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+        # All Alpha code is PIC.
+        _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+        ;;
+      esac
+      ;;
+
+    osf3* | osf4* | osf5*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      # All OSF/1 code is PIC.
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
+      ;;
+
+    sco3.2v5*)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kpic'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-dn'
+      ;;
+
+    solaris*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sunos4*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec ;then
+	_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
+	_LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      fi
+      ;;
+
+    uts4*)
+      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
+      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
+      ;;
+
+    *)
+      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
+      ;;
+    esac
+  fi
+])
+case "$host_os" in
+  # For platforms which do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+    ;;
+  *)
+    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
+    ;;
+esac
+AC_MSG_RESULT([$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)])
+_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
+	[How to pass a linker flag through the compiler])
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)"; then
+  AC_LIBTOOL_COMPILER_OPTION([if $compiler PIC flag $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) works],
+    [_LT_AC_TAGVAR(lt_prog_compiler_pic_works, $1)],
+    [$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
+    [case $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) in
+     "" | " "*) ;;
+     *) _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)" ;;
+     esac],
+    [_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
+     _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
+fi
+_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
+	[Additional compiler flags for building library objects])
+
+#
+# Check to make sure the static flag actually works.
+#
+AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $_LT_AC_TAGVAR(lt_prog_compiler_static, $1) works],
+  _LT_AC_TAGVAR(lt_prog_compiler_static_works, $1),
+  $_LT_AC_TAGVAR(lt_prog_compiler_static, $1),
+  [],
+  [_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=])
+_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
+	[Compiler flag to prevent dynamic linking])
+])# AC_LIBTOOL_PROG_COMPILER_PIC
+
+
+# AC_LIBTOOL_PROG_LD_SHLIBS([TAGNAME])
+# ------------------------------------
+# See if the linker supports building shared libraries.
+AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS],
+[AC_REQUIRE([LT_AC_PROG_EGREP])dnl
+AC_REQUIRE([AC_PROG_LD])dnl
+AC_REQUIRE([AC_PROG_NM])dnl
+AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])dnl
+AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+m4_if([$1], [CXX], [
+  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  case $host_os in
+  aix4* | aix5*)
+    # If we're using GNU nm, then we don't want the "-C" option.
+    # -C means demangle to AIX nm, but means don't demangle with GNU nm
+    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+    else
+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+    fi
+    ;;
+  pw32*)
+    _LT_AC_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
+  ;;
+  cygwin* | mingw*)
+    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([[^ ]]*\) [[^ ]]*/\1 DATA/;/^I /d;/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  *)
+    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  ;;
+  esac
+], [
+  runpath_var=
+  _LT_AC_TAGVAR(allow_undefined_flag, $1)=
+  _LT_AC_TAGVAR(always_export_symbols, $1)=no
+  _LT_AC_TAGVAR(archive_cmds, $1)=
+  _LT_AC_TAGVAR(archive_expsym_cmds, $1)=
+  _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+  _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
+  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  _LT_AC_TAGVAR(hardcode_automatic, $1)=no
+  _LT_AC_TAGVAR(hardcode_direct, $1)=no
+  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+  _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+  _LT_AC_TAGVAR(hardcode_minus_L, $1)=no
+  _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+  _LT_AC_TAGVAR(inherit_rpath, $1)=no
+  _LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
+  _LT_AC_TAGVAR(module_cmds, $1)=
+  _LT_AC_TAGVAR(module_expsym_cmds, $1)=
+  _LT_AC_TAGVAR(old_archive_from_new_cmds, $1)=
+  _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)=
+  _LT_AC_TAGVAR(thread_safe_flag_spec, $1)=
+  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  _LT_AC_TAGVAR(include_expsyms, $1)=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ` (' and `)$', so one must not match beginning or
+  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
+  # as well as any symbol that contains `d'.
+  _LT_AC_TAGVAR(exclude_expsyms, $1)="_GLOBAL_OFFSET_TABLE_"
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  extract_expsyms_cmds=
+
+  case $host_os in
+  cygwin* | mingw* | pw32*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+  esac
+
+  _LT_AC_TAGVAR(ld_shlibs, $1)=yes
+  if test "$with_gnu_ld" = yes; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='${wl}'
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix3* | aix4* | aix5*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.9.1, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to modify your PATH
+*** so that a non-GNU linker is found, and then restart.
+
+_LT_EOF
+      fi
+      ;;
+
+    amigaos*)
+      if test "$host_cpu" = m68k; then
+        _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+        _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      fi
+
+      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
+      # that the semantics of dynamic libraries on AmigaOS, at least up
+      # to version 4, is to share data among multiple programs linked
+      # with the same dynamic library.  Since this doesn't match the
+      # behavior of shared libraries on other platforms, we can't use
+      # them.
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+      # as there is no search path for DLLs.
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_AC_TAGVAR(always_export_symbols, $1)=no
+      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
+	# If the export-symbols file already is a .def file (1st line
+	# is EXPORTS), use it as is; otherwise, prepend...
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+	  cp $export_symbols $output_objdir/$soname.def;
+	else
+	  echo EXPORTS > $output_objdir/$soname.def;
+	  cat $export_symbols >> $output_objdir/$soname.def;
+	fi~
+	$CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000  ${wl}--out-implib,$lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris* | sysv5*)
+      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+
+    sunos4*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+  linux*)
+    if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null; then
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
+        *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+        *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+        *\ 2.11.*) ;; # other 2.11 versions
+        *) supports_anon_versioning=yes ;;
+      esac
+      if test "x$supports_anon_versioning" = xyes; then
+        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~$echo "local: *; };" >> $output_objdir/$libname.ver~$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
+      else
+        _LT_AC_TAGVAR(archive_expsym_cmds, $1)=$_LT_AC_TAGVAR(archive_cmds, $1)
+      fi
+    else
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+    fi
+    ;;
+
+    *)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+      ;;
+    esac
+
+    if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = yes; then
+      runpath_var=LD_RUN_PATH
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+      # ancient GNU ld didn't support --whole-archive et. al.
+      if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+ 	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      else
+  	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+      fi
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_AC_TAGVAR(always_export_symbols, $1)=yes
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      if test "$GCC" = yes && test -z "$link_static_flag"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	_LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
+      fi
+      ;;
+
+    aix4* | aix5*)
+      if test "$host_cpu" = ia64; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=""
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to AIX nm, but means don't demangle with GNU nm
+	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+	  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+	else
+	  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# need to do runtime linking.
+	case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
+	  for ld_flag in $LDFLAGS; do
+  	  if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+  	    aix_use_runtimelinking=yes
+  	    break
+  	  fi
+	  done
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      _LT_AC_TAGVAR(archive_cmds, $1)=''
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+      if test "$GCC" = yes; then
+	case $host_os in aix4.[012]|aix4.[012].*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`${CC} -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+  	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+  	  # We have reworked collect2
+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+	  else
+  	  # We have old collect2
+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
+  	  # It fails to find uninstalled libraries when the uninstalled
+  	  # path is not listed in the libpath.  Setting hardcode_minus_L
+  	  # to unsupported forces relinking
+  	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+  	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+  	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+	  fi
+	esac
+	shared_flag='-shared'
+      else
+	# not using gcc
+	if test "$host_cpu" = ia64; then
+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+  	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+  	if test "$aix_use_runtimelinking" = yes; then
+	    shared_flag='${wl}-G'
+	  else
+	    shared_flag='${wl}-bM:SRE'
+  	fi
+	fi
+      fi
+
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      _LT_AC_TAGVAR(always_export_symbols, $1)=yes
+      if test "$aix_use_runtimelinking" = yes; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'
+        # Determine the default libpath from the value encoded in an
+        # empty executable.
+       _LT_AC_SYS_LIBPATH_AIX
+       _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+      else
+	if test "$host_cpu" = ia64; then
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an
+	 # empty executable.
+	 _LT_AC_SYS_LIBPATH_AIX
+	 _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+	  # -bexpall does not export symbols beginning with underscore (_)
+	  _LT_AC_TAGVAR(always_export_symbols, $1)=yes
+	  # Exported symbols can be pulled into shared objects from archives
+	  _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '
+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+	  # This is similar to how AIX traditionally builds it's shared libraries.
+	  _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      if test "$host_cpu" = m68k; then
+        _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+        _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      fi
+      # see comment about different semantics on the GNU ld section
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+
+    bsdi4*)
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      # Tell ltmain to make .lib files, not .a files.
+      libext=lib
+      # Tell ltmain to make .dll files, not .so files.
+      shrext_cmds=".dll"
+      # FIXME: Setting linknames here is a bad hack.
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='
+      # The linker will automatically build a .lib file if we build a DLL.
+      _LT_AC_TAGVAR(old_archive_from_new_cmds, $1)='true'
+      # FIXME: Should let the user specify the lib program.
+      _LT_AC_TAGVAR(old_archive_cmds, $1)='lib /OUT:$oldlib$oldobjs$old_deplibs'
+      fix_srcfile_path='`cygpath -w "$srcfile"`'
+      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      ;;
+
+    darwin* | rhapsody*)
+      case "$host_os" in
+        rhapsody* | darwin1.[[012]])
+         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${Wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[[012]])
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+      esac
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_AC_TAGVAR(hardcode_direct, $1)=no
+      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+    if test "$GCC" = yes ; then
+    	output_verbose_link_cmd='echo'
+        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+    else
+      case "$cc_basename" in
+        xlc*)
+         output_verbose_link_cmd='echo'
+          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+          _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
+          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         _LT_AC_TAGVAR(ld_shlibs, $1)=no
+          ;;
+      esac     
+    fi
+      ;;
+    dgux*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    freebsd1*)
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+
+    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | kfreebsd*-gnu)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    hpux9*)
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      ;;
+
+    hpux10* | hpux11*)
+      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
+	case "$host_cpu" in
+	hppa*64*|ia64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case "$host_cpu" in
+	hppa*64*|ia64*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  ;;
+	*)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+	  ;;
+	esac
+      fi
+      if test "$with_gnu_ld" = no; then
+	case "$host_cpu" in
+	hppa*64*)
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no
+	  _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+	  ;;
+	ia64*)
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no
+	  _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+	  ;;
+	*)
+	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+	  _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(inherit_rpath, $1)=yes
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    newsos6)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    openbsd*)
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      else
+       case $host_os in
+	 openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
+	   _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+	   _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+	   ;;
+	 *)
+	   _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	   _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+	   ;;
+       esac
+      fi
+      ;;
+
+    os2*)
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_AC_TAGVAR(archive_cmds, $1)='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
+      _LT_AC_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      ;;
+
+    osf3*)
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+      else
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      else
+	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~
+	$LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      ;;
+
+    sco3.2v5*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
+      runpath_var=LD_RUN_PATH
+      hardcode_runpath_var=yes
+      ;;
+
+    solaris*)
+      _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+	  $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  	$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      case $host_os in
+      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
+      *) # Supported since Solaris 2.6 (maybe 2.5.1?)
+	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;;
+      esac
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+      ;;
+
+    sunos4*)
+      if test "x$host_vendor" = xsequent; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_AC_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no
+        ;;
+	motorola)
+	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  _LT_AC_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv4.3*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	_LT_AC_TAGVAR(ld_shlibs, $1)=yes
+      fi
+      ;;
+
+    sysv4.2uw2*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=no
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      hardcode_runpath_var=yes
+      runpath_var=LD_RUN_PATH
+      ;;
+
+   sysv5OpenUNIX8* | sysv5UnixWare7* |  sysv5uw[[78]]* | unixware7*)
+      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z ${wl}text'
+      if test "$GCC" = yes; then
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      runpath_var='LD_RUN_PATH'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    sysv5*)
+      _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'
+      # $CC -shared without GNU ld will not create a library from C++
+      # object files and a static libstdc++, better avoid it by now
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  		$LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      runpath_var='LD_RUN_PATH'
+      ;;
+
+    uts4*)
+      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      ;;
+
+    *)
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    esac
+
+    if test x$host_vendor = xsni; then
+      case $host in
+      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+	export_dynamic_flag_spec='${wl}-Blargedynsym'
+	;;
+      esac
+    fi
+  fi
+])
+AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])
+test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
+_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
+_LT_DECL([], [extract_expsyms_cmds], [2],
+    [The commands to extract the exported symbol list from a shared archive])
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test "$GCC" = yes; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+_LT_DECL([], [variables_saved_for_relink], [1],
+    [Variables whose values should be saved in libtool wrapper scripts and
+    restored at link time])
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)" in
+x|xyes)
+  # Assume -lc should be added
+  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+
+  if test "$enable_shared" = yes && test "$GCC" = yes; then
+    case $_LT_AC_TAGVAR(archive_cmds, $1) in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      AC_MSG_CHECKING([whether -lc should be explicitly linked in])
+      $rm conftest*
+      printf "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+      if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
+        soname=conftest
+        lib=conftest
+        libobjs=conftest.$ac_objext
+        deplibs=
+        wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)
+        compiler_flags=-v
+        linker_flags=-v
+        verstring=
+        output_objdir=.
+        libname=conftest
+        lt_save_allow_undefined_flag=$_LT_AC_TAGVAR(allow_undefined_flag, $1)
+        _LT_AC_TAGVAR(allow_undefined_flag, $1)=
+        if AC_TRY_EVAL(_LT_AC_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
+        then
+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+        else
+	  _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+        fi
+        _LT_AC_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
+      else
+        cat conftest.err 1>&5
+      fi
+      $rm conftest*
+      AC_MSG_RESULT([$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)])
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
+    [Whether or not to add -lc for building shared libraries])
+_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
+    [enable_shared_with_static_runtimes], [0],
+    [Whether or not to disallow shared libs when runtime libs are static])
+_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
+    [Compiler flag to allow reflexive dlopens])
+_LT_TAGDECL([], [whole_archive_flag_spec], [1],
+    [Compiler flag to generate shared objects directly from archives])
+_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
+    [Create an old-style archive from a shared archive])
+_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
+    [Create a temporary old-style archive to link instead of a shared archive])
+_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
+_LT_TAGDECL([], [archive_expsym_cmds], [2])
+_LT_TAGDECL([], [module_cmds], [2],
+    [Commands used to build a loadable module if different from building
+    a shared archive.])
+_LT_TAGDECL([], [module_expsym_cmds], [2])
+_LT_TAGDECL([], [allow_undefined_flag], [1],
+    [Flag that allows shared libraries with undefined symbols to be built])
+_LT_TAGDECL([], [no_undefined_flag], [1],
+    [Flag that enforces no undefined symbols])
+_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
+    [Flag to hardcode $libdir into a binary during linking.
+    This must work even if $libdir does not exist])
+_LT_TAGDECL([], [hardcode_libdir_flag_spec_ld], [1],
+    [If ld is used when linking, flag to hardcode $libdir into a binary
+    during linking.  This must work even if $libdir does not exist])
+_LT_TAGDECL([], [hardcode_libdir_separator], [1],
+    [Whether we need a single "-rpath" flag with a separated argument])
+_LT_TAGDECL([], [hardcode_direct], [0],
+    [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
+    DIR into the resulting binary])
+_LT_TAGDECL([], [hardcode_minus_L], [0],
+    [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+    into the resulting binary])
+_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
+    [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+    into the resulting binary])
+_LT_TAGDECL([], [hardcode_automatic], [0],
+    [Set to "yes" if building a shared library automatically hardcodes DIR
+    into the library and all subsequent libraries and executables linked
+    against it])
+_LT_TAGDECL([], [inherit_rpath], [0],
+    [Set to yes if linker adds runtime paths of dependent libraries
+    to runtime path list])
+_LT_TAGDECL([], [link_all_deplibs], [0],
+    [Whether libtool must link a program against all its dependency libraries])
+_LT_TAGDECL([], [fix_srcfile_path], [1],
+    [Fix the shell variable $srcfile for the compiler])
+_LT_TAGDECL([], [always_export_symbols], [0],
+    [Set to "yes" if exported symbols are required])
+_LT_TAGDECL([], [export_symbols_cmds], [2],
+    [The commands to list exported symbols])
+_LT_TAGDECL([], [exclude_expsyms], [1],
+    [Symbols that should not be listed in the preloaded symbols])
+_LT_TAGDECL([], [include_expsyms], [1],
+    [Symbols that must always be exported])
+dnl FIXME: Not yet implemented
+dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
+dnl    [Compiler flag to generate thread safe objects])
+])# AC_LIBTOOL_PROG_LD_SHLIBS
+
+
+# _LT_LANG_C_CONFIG([TAG])
+# ------------------------
+# Ensure that the configuration variables for a C compiler are suitably
+# defined.  These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to `libtool'.
+m4_define([_LT_LANG_C_CONFIG],
+[AC_REQUIRE([LT_AC_PROG_EGREP])
+lt_save_CC="$CC"
+AC_LANG_PUSH(C)
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}\n'
+
+_LT_AC_SYS_COMPILER
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_AC_TAGVAR(compiler, []) is a NOP.
+compiler_DEFAULT=$CC
+
+#
+# Check for any special shared library compilation flags.
+#
+_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)=
+if test "$GCC" = no; then
+  case $host_os in
+  sco3.2v5*)
+    _LT_AC_TAGVAR(lt_prog_cc_shlib, $1)='-belf'
+    ;;
+  esac
+fi
+if test -n "$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)"; then
+  AC_MSG_WARN([`$CC' requires `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to build shared libraries])
+  if echo "$old_CC $old_CFLAGS " | $GREP "[[ 	]]$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)[[ 	]]" >/dev/null; then :
+  else
+    AC_MSG_WARN([add `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to the CC or CFLAGS env variable and reconfigure])
+    _LT_AC_TAGVAR(lt_cv_prog_cc_can_build_shared, $1)=no
+  fi
+fi
+
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+  AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
+  AC_LIBTOOL_PROG_COMPILER_PIC($1)
+  AC_LIBTOOL_PROG_CC_C_O($1)
+  AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+  AC_LIBTOOL_PROG_LD_SHLIBS($1)
+  AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+  AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+  AC_LIBTOOL_SYS_LIB_STRIP
+  AC_LIBTOOL_DLOPEN_SELF($1)
+
+  # Report which library types will actually be built
+  AC_MSG_CHECKING([if libtool supports shared libraries])
+  AC_MSG_RESULT([$can_build_shared])
+
+  AC_MSG_CHECKING([whether to build shared libraries])
+  test "$can_build_shared" = "no" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case "$host_os" in
+  aix3*)
+    test "$enable_shared" = yes && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+
+  aix4* | aix5*)
+    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
+      test "$enable_shared" = yes && enable_static=no
+    fi
+    ;;
+  esac
+  AC_MSG_RESULT([$enable_shared])
+
+  AC_MSG_CHECKING([whether to build static libraries])
+  # Make sure either enable_shared or enable_static is yes.
+  test "$enable_shared" = yes || enable_static=yes
+  AC_MSG_RESULT([$enable_static])
+
+  _LT_CONFIG($1)
+fi
+AC_LANG_POP
+CC="$lt_save_CC"
+])# _LT_LANG_C_CONFIG
+
+
+# _LT_LANG_CXX_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a C++ compiler are suitably
+# defined.  These variables are subsequently used by _LT_CONFIG to write
+# the compiler configuration to `libtool'.
+m4_define([_LT_LANG_CXX_CONFIG],
+[AC_LANG_PUSH(C++)
+AC_REQUIRE([LT_AC_PROG_EGREP])
+AC_REQUIRE([AC_PROG_CXX])
+AC_REQUIRE([AC_PROG_CXXCPP])
+
+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_AC_TAGVAR(allow_undefined_flag, $1)=
+_LT_AC_TAGVAR(always_export_symbols, $1)=no
+_LT_AC_TAGVAR(archive_expsym_cmds, $1)=
+_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_direct, $1)=no
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_AC_TAGVAR(hardcode_minus_L, $1)=no
+_LT_AC_TAGVAR(hardcode_automatic, $1)=no
+_LT_AC_TAGVAR(inherit_rpath, $1)=no
+_LT_AC_TAGVAR(module_cmds, $1)=
+_LT_AC_TAGVAR(module_expsym_cmds, $1)=
+_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_AC_TAGVAR(no_undefined_flag, $1)=
+_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for C++ test sources.
+ac_ext=cc
+
+# Object file extension for compiled C++ test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(int, char *[]) { return(0); }\n'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_LD=$LD
+lt_save_GCC=$GCC
+GCC=$GXX
+lt_save_with_gnu_ld=$with_gnu_ld
+lt_save_path_LD=$lt_cv_path_LD
+if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+  lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+else
+  unset lt_cv_prog_gnu_ld
+fi
+if test -n "${lt_cv_path_LDCXX+set}"; then
+  lt_cv_path_LD=$lt_cv_path_LDCXX
+else
+  unset lt_cv_path_LD
+fi
+test -z "${LDCXX+set}" || LD=$LDCXX
+CC=${CXX-"c++"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
+
+if test -n "$compiler"; then
+  # We don't want -fno-exception when compiling C++ code, so set the
+  # no_builtin_flag separately
+  if test "$GXX" = yes; then
+    _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
+  else
+    _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
+  fi
+
+  if test "$GXX" = yes; then
+    # Set up default GNU C++ configuration
+
+    AC_PROG_LD
+
+    # Check if GNU C++ uses GNU ld as the underlying linker, since the
+    # archiving commands below assume that GNU ld is being used.
+    if test "$with_gnu_ld" = yes; then
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+      # If archive_cmds runs LD, not CC, wlarc should be empty
+      # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+      #     investigate it a little bit more. (MM)
+      wlarc='${wl}'
+
+      # ancient GNU ld didn't support --whole-archive et. al.
+      if eval "`$CC -print-prog-name=ld` --help 2>&1" |
+  	$GREP 'no-whole-archive' > /dev/null; then
+        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
+      else
+        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+      fi
+    else
+      with_gnu_ld=no
+      wlarc=
+
+      # A generic and very simple default shared library creation
+      # command for GNU C++ for the case where it uses the native
+      # linker, instead of GNU ld.  If possible, this setting should
+      # overridden to take advantage of the native linker features on
+      # the platform it is being used on.
+      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+    fi
+
+    # Commands to make compiler produce verbose output that lists
+    # what "hidden" libraries, object files and flags are used when
+    # linking a shared library.
+    output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
+
+  else
+    GXX=no
+    with_gnu_ld=no
+    wlarc=
+  fi
+
+  # PORTME: fill in a description of your system's C++ link characteristics
+  AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
+  _LT_AC_TAGVAR(ld_shlibs, $1)=yes
+  case $host_os in
+    aix3*)
+      # FIXME: insert proper C++ library support
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    aix4* | aix5*)
+      if test "$host_cpu" = ia64; then
+        # On IA64, the linker does run time linking by default, so we don't
+        # have to do anything special.
+        aix_use_runtimelinking=no
+        exp_sym_flag='-Bexport'
+        no_entry_flag=""
+      else
+        aix_use_runtimelinking=no
+
+        # Test if we are trying to use run time linking or normal
+        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+        # need to do runtime linking.
+        case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
+  	for ld_flag in $LDFLAGS; do
+  	  case $ld_flag in
+  	  *-brtl*)
+  	    aix_use_runtimelinking=yes
+  	    break
+  	    ;;
+  	  esac
+  	done
+        esac
+
+        exp_sym_flag='-bexport'
+        no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      _LT_AC_TAGVAR(archive_cmds, $1)=''
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+      if test "$GXX" = yes; then
+        case $host_os in aix4.[012]|aix4.[012].*)
+        # We only want to do this on AIX 4.2 and lower, the check
+        # below for broken collect2 doesn't work under 4.3+
+  	collect2name=`${CC} -print-prog-name=collect2`
+  	if test -f "$collect2name" &&
+  	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+  	then
+  	  # We have reworked collect2
+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+  	else
+  	  # We have old collect2
+  	  _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
+  	  # It fails to find uninstalled libraries when the uninstalled
+  	  # path is not listed in the libpath.  Setting hardcode_minus_L
+  	  # to unsupported forces relinking
+  	  _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
+  	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+  	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+  	fi
+        esac
+        shared_flag='-shared'
+      else
+        # not using gcc
+        if test "$host_cpu" = ia64; then
+  	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+  	# chokes on -Wl,-G. The following line is correct:
+  	shared_flag='-G'
+        else
+  	if test "$aix_use_runtimelinking" = yes; then
+  	  shared_flag='${wl}-G'
+  	else
+  	  shared_flag='${wl}-bM:SRE'
+  	fi
+        fi
+      fi
+
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      _LT_AC_TAGVAR(always_export_symbols, $1)=yes
+      if test "$aix_use_runtimelinking" = yes; then
+        # Warning - without using the other runtime loading flags (-brtl),
+        # -berok will link without error, but may produce a broken library.
+        _LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'
+        # Determine the default libpath from the value encoded in an empty
+        # executable.
+        _LT_AC_SYS_LIBPATH_AIX
+        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+
+        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
+       else
+        if test "$host_cpu" = ia64; then
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
+  	_LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
+        else
+  	# Determine the default libpath from the value encoded in an
+  	# empty executable.
+  	_LT_AC_SYS_LIBPATH_AIX
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
+  	# Warning - without using the other run time loading flags,
+  	# -berok will link without error, but may produce a broken library.
+  	_LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
+  	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
+  	# -bexpall does not export symbols beginning with underscore (_)
+  	_LT_AC_TAGVAR(always_export_symbols, $1)=yes
+  	# Exported symbols can be pulled into shared objects from archives
+  	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '
+  	_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
+  	# This is similar to how AIX traditionally builds it's shared libraries.
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+        fi
+      fi
+      ;;
+    chorus*)
+      case $cc_basename in
+        *)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+      esac
+      ;;
+
+    cygwin* | mingw* | pw32*)
+      # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
+      # as there is no search path for DLLs.
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
+      _LT_AC_TAGVAR(always_export_symbols, $1)=no
+      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
+        # If the export-symbols file already is a .def file (1st line
+        # is EXPORTS), use it as is; otherwise, prepend...
+        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
+  	cp $export_symbols $output_objdir/$soname.def;
+        else
+  	echo EXPORTS > $output_objdir/$soname.def;
+  	cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
+      else
+        _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      fi
+    ;;
+      darwin* | rhapsody*)
+        case "$host_os" in
+        rhapsody* | darwin1.[[012]])
+         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
+         ;;
+       *) # Darwin 1.3 on
+         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
+           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${Wl}suppress'
+         else
+           case ${MACOSX_DEPLOYMENT_TARGET} in
+             10.[[012]])
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
+               ;;
+             10.*)
+               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
+               ;;
+           esac
+         fi
+         ;;
+        esac
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      _LT_AC_TAGVAR(hardcode_direct, $1)=no
+      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
+      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
+      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'
+      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+    if test "$GXX" = yes ; then
+      lt_int_apple_cc_single_mod=no
+      output_verbose_link_cmd='echo'
+      if $CC -dumpspecs 2>&1 | $GREP 'single_module' >/dev/null ; then
+       lt_int_apple_cc_single_mod=yes
+      fi
+      if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
+       _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+      else
+          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
+        fi
+        _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+        # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
+          if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
+            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          else
+            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          fi
+            _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+      else
+      case "$cc_basename" in
+        xlc*)
+         output_verbose_link_cmd='echo'
+          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
+          _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
+          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
+          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
+          ;;
+       *)
+         _LT_AC_TAGVAR(ld_shlibs, $1)=no
+          ;;
+      esac
+      fi
+        ;;
+
+    dgux*)
+      case $cc_basename in
+        ec++)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        ghcx)
+  	# Green Hills C++ Compiler
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        *)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+      esac
+      ;;
+    freebsd[12]*)
+      # C++ shared libraries reported to be fairly broken before switch to ELF
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    freebsd-elf*)
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      ;;
+    freebsd* | kfreebsd*-gnu)
+      # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+      # conventions
+      _LT_AC_TAGVAR(ld_shlibs, $1)=yes
+      ;;
+    gnu*)
+      ;;
+    hpux9*)
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+  				# but as the default
+  				# location of the library.
+
+      case $cc_basename in
+      CC)
+        # FIXME: insert proper C++ library support
+        _LT_AC_TAGVAR(ld_shlibs, $1)=no
+        ;;
+      aCC)
+        _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+        # Commands to make compiler produce verbose output that lists
+        # what "hidden" libraries, object files and flags are used when
+        # linking a shared library.
+        #
+        # There doesn't appear to be a way to prevent this compiler from
+        # explicitly linking system object files so we need to strip them
+        # from the output so that they don't get included in the library
+        # dependencies.
+        output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+        ;;
+      *)
+        if test "$GXX" = yes; then
+          _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
+        else
+          # FIXME: insert proper C++ library support
+          _LT_AC_TAGVAR(ld_shlibs, $1)=no
+        fi
+        ;;
+      esac
+      ;;
+    hpux10*|hpux11*)
+      if test $with_gnu_ld = no; then
+        case "$host_cpu" in
+        hppa*64*)
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+          ;;
+        ia64*)
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+          ;;
+        *)
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+  	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
+          ;;
+        esac
+      fi
+      case "$host_cpu" in
+      hppa*64*)
+        _LT_AC_TAGVAR(hardcode_direct, $1)=no
+        _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+        ;;
+      ia64*)
+        _LT_AC_TAGVAR(hardcode_direct, $1)=no
+        _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+        _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+  					      # but as the default
+  					      # location of the library.
+        ;;
+      *)
+        _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+        _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
+  					      # but as the default
+  					      # location of the library.
+        ;;
+      esac
+
+      case $cc_basename in
+        CC)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        aCC)
+  	case "$host_cpu" in
+  	hppa*64*|ia64*)
+  	  _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'
+  	  ;;
+  	*)
+  	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+  	  ;;
+  	esac
+  	# Commands to make compiler produce verbose output that lists
+  	# what "hidden" libraries, object files and flags are used when
+  	# linking a shared library.
+  	#
+  	# There doesn't appear to be a way to prevent this compiler from
+  	# explicitly linking system object files so we need to strip them
+  	# from the output so that they don't get included in the library
+  	# dependencies.
+  	output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+  	;;
+        *)
+  	if test "$GXX" = yes; then
+  	  if test $with_gnu_ld = no; then
+  	    case "$host_cpu" in
+  	    ia64*|hppa*64*)
+  	      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'
+  	      ;;
+  	    *)
+  	      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+  	      ;;
+  	    esac
+  	  fi
+  	else
+  	  # FIXME: insert proper C++ library support
+  	  _LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	fi
+  	;;
+      esac
+      ;;
+    irix5* | irix6*)
+      case $cc_basename in
+        CC)
+  	# SGI C++
+  	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
+
+  	# Archives containing C++ object files must be created using
+  	# "CC -ar", where "CC" is the IRIX C++ compiler.  This is
+  	# necessary to make sure instantiated templates are included
+  	# in the archive.
+  	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
+  	;;
+        *)
+  	if test "$GXX" = yes; then
+  	  if test "$with_gnu_ld" = no; then
+  	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
+  	  else
+  	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib'
+  	  fi
+  	fi
+  	_LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+  	;;
+      esac
+      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+      _LT_AC_TAGVAR(inherit_rpath, $1)=yes
+      ;;
+    linux*)
+      case $cc_basename in
+        KCC)
+  	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+  	# KCC will only create a shared library if the output file
+  	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+  	# to its proper name (with version) after linking.
+  	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
+  	# Commands to make compiler produce verbose output that lists
+  	# what "hidden" libraries, object files and flags are used when
+  	# linking a shared library.
+  	#
+  	# There doesn't appear to be a way to prevent this compiler from
+  	# explicitly linking system object files so we need to strip them
+  	# from the output so that they don't get included in the library
+  	# dependencies.
+  	output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath,$libdir'
+  	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+
+  	# Archives containing C++ object files must be created using
+  	# "CC -Bstatic", where "CC" is the KAI C++ compiler.
+  	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
+  	;;
+        icpc)
+  	# Intel C++
+  	with_gnu_ld=yes
+  	_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+  	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+  	_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
+  	_LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
+  	;;
+        cxx)
+  	# Compaq C++
+  	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
+
+  	runpath_var=LD_RUN_PATH
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+  	# Commands to make compiler produce verbose output that lists
+  	# what "hidden" libraries, object files and flags are used when
+  	# linking a shared library.
+  	#
+  	# There doesn't appear to be a way to prevent this compiler from
+  	# explicitly linking system object files so we need to strip them
+  	# from the output so that they don't get included in the library
+  	# dependencies.
+  	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+  	;;
+      esac
+      ;;
+    lynxos*)
+      # FIXME: insert proper C++ library support
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    m88k*)
+      # FIXME: insert proper C++ library support
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    mvs*)
+      case $cc_basename in
+        cxx)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        *)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+      esac
+      ;;
+    netbsd*)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+        _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+        wlarc=
+        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+        _LT_AC_TAGVAR(hardcode_direct, $1)=yes
+        _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+      fi
+      # Workaround some broken pre-1.5 toolchains
+      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+      ;;
+    osf3*)
+      case $cc_basename in
+        KCC)
+  	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+  	# KCC will only create a shared library if the output file
+  	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+  	# to its proper name (with version) after linking.
+  	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+  	# Archives containing C++ object files must be created using
+  	# "CC -Bstatic", where "CC" is the KAI C++ compiler.
+  	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
+
+  	;;
+        RCC)
+  	# Rational C++ 2.4.1
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        cxx)
+  	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+  	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
+
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+  	# Commands to make compiler produce verbose output that lists
+  	# what "hidden" libraries, object files and flags are used when
+  	# linking a shared library.
+  	#
+  	# There doesn't appear to be a way to prevent this compiler from
+  	# explicitly linking system object files so we need to strip them
+  	# from the output so that they don't get included in the library
+  	# dependencies.
+  	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+  	;;
+        *)
+  	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+  	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+  	  _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
+
+  	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+  	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+  	  # Commands to make compiler produce verbose output that lists
+  	  # what "hidden" libraries, object files and flags are used when
+  	  # linking a shared library.
+  	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
+
+  	else
+  	  # FIXME: insert proper C++ library support
+  	  _LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	fi
+  	;;
+      esac
+      ;;
+    osf4* | osf5*)
+      case $cc_basename in
+        KCC)
+  	# Kuck and Associates, Inc. (KAI) C++ Compiler
+
+  	# KCC will only create a shared library if the output file
+  	# ends with ".so" (or ".sl" for HP-UX), so rename the library
+  	# to its proper name (with version) after linking.
+  	_LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+  	# Archives containing C++ object files must be created using
+  	# the KAI C++ compiler.
+  	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs'
+  	;;
+        RCC)
+  	# Rational C++ 2.4.1
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        cxx)
+  	_LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
+  	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+  	  echo "-hidden">> $lib.exp~
+  	  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp  `test -n "$verstring" && echo -set_version	$verstring` -update_registry $objdir/so_locations -o $lib~
+  	  $rm $lib.exp'
+
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
+  	_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+  	# Commands to make compiler produce verbose output that lists
+  	# what "hidden" libraries, object files and flags are used when
+  	# linking a shared library.
+  	#
+  	# There doesn't appear to be a way to prevent this compiler from
+  	# explicitly linking system object files so we need to strip them
+  	# from the output so that they don't get included in the library
+  	# dependencies.
+  	output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+  	;;
+        *)
+  	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+  	  _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
+  	 _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
+
+  	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
+  	  _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
+
+  	  # Commands to make compiler produce verbose output that lists
+  	  # what "hidden" libraries, object files and flags are used when
+  	  # linking a shared library.
+  	  output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
+
+  	else
+  	  # FIXME: insert proper C++ library support
+  	  _LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	fi
+  	;;
+      esac
+      ;;
+    psos*)
+      # FIXME: insert proper C++ library support
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    sco*)
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      case $cc_basename in
+        CC)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        *)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+      esac
+      ;;
+    sunos4*)
+      case $cc_basename in
+        CC)
+  	# Sun C++ 4.x
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        lcc)
+  	# Lucid
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        *)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+      esac
+      ;;
+    solaris*)
+      case $cc_basename in
+        CC)
+  	# Sun C++ 4.2, 5.x and Centerline C++
+  	_LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs'
+  	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -nolib -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+  	_LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  	$CC -G${allow_undefined_flag} -nolib ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+  	_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
+  	_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
+  	case $host_os in
+  	  solaris2.[0-5] | solaris2.[0-5].*) ;;
+  	  *)
+  	    # The C++ compiler is used as linker so we must use $wl
+  	    # flag to pass the commands to the underlying system
+  	    # linker. We must also pass each convience library through
+  	    # to the system linker between allextract/defaultextract.
+  	    # The C++ compiler will combine linker options so we
+  	    # cannot just pass the convience library names through
+  	    # without $wl.
+  	    # Supported since Solaris 2.6 (maybe 2.5.1?)
+  	    _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'
+  	    ;;
+  	esac
+  	_LT_AC_TAGVAR(link_all_deplibs, $1)=yes
+
+  	# Commands to make compiler produce verbose output that lists
+  	# what "hidden" libraries, object files and flags are used when
+  	# linking a shared library.
+  	#
+  	# There doesn't appear to be a way to prevent this compiler from
+  	# explicitly linking system object files so we need to strip them
+  	# from the output so that they don't get included in the library
+  	# dependencies.
+  	output_verbose_link_cmd='templist=`$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-[[LR]]"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
+
+  	# Archives containing C++ object files must be created using
+  	# "CC -xar", where "CC" is the Sun C++ compiler.  This is
+  	# necessary to make sure instantiated templates are included
+  	# in the archive.
+  	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
+  	;;
+        gcx)
+  	# Green Hills C++ Compiler
+  	_LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+
+  	# The C++ compiler must be used to create the archive.
+  	_LT_AC_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+  	;;
+        *)
+  	# GNU C++ compiler with Solaris linker
+  	if test "$GXX" = yes && test "$with_gnu_ld" = no; then
+  	  _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
+  	  if $CC --version | $GREP -v '^2\.7' > /dev/null; then
+  	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+  	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  		$CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+  	    # Commands to make compiler produce verbose output that lists
+  	    # what "hidden" libraries, object files and flags are used when
+  	    # linking a shared library.
+  	    output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP \"\-L\""
+  	  else
+  	    # g++ 2.7 appears to require `-G' NOT `-shared' on this
+  	    # platform.
+  	    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
+  	    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
+  		$CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
+
+  	    # Commands to make compiler produce verbose output that lists
+  	    # what "hidden" libraries, object files and flags are used when
+  	    # linking a shared library.
+  	    output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP \"\-L\""
+  	  fi
+
+  	  _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
+  	fi
+  	;;
+      esac
+      ;;
+    sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*)
+      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+      ;;
+    tandem*)
+      case $cc_basename in
+        NCC)
+  	# NonStop-UX NCC 3.20
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+        *)
+  	# FIXME: insert proper C++ library support
+  	_LT_AC_TAGVAR(ld_shlibs, $1)=no
+  	;;
+      esac
+      ;;
+    vxworks*)
+      # FIXME: insert proper C++ library support
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+    *)
+      # FIXME: insert proper C++ library support
+      _LT_AC_TAGVAR(ld_shlibs, $1)=no
+      ;;
+  esac
+  AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])
+  test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+  _LT_AC_TAGVAR(GCC, $1)="$GXX"
+  _LT_AC_TAGVAR(LD, $1)="$LD"
+
+  ## CAVEAT EMPTOR:
+  ## There is no encapsulation within the following macros, do not change
+  ## the running order or otherwise move them around unless you know exactly
+  ## what you are doing...
+  AC_LIBTOOL_POSTDEP_PREDEP($1)
+  AC_LIBTOOL_PROG_COMPILER_PIC($1)
+  AC_LIBTOOL_PROG_CC_C_O($1)
+  AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+  AC_LIBTOOL_PROG_LD_SHLIBS($1)
+  AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+  AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+  AC_LIBTOOL_SYS_LIB_STRIP
+  AC_LIBTOOL_DLOPEN_SELF($1)
+
+  _LT_CONFIG($1)
+fi
+
+AC_LANG_POP
+CC=$lt_save_CC
+LDCXX=$LD
+LD=$lt_save_LD
+GCC=$lt_save_GCC
+with_gnu_ldcxx=$with_gnu_ld
+with_gnu_ld=$lt_save_with_gnu_ld
+lt_cv_path_LDCXX=$lt_cv_path_LD
+lt_cv_path_LD=$lt_save_path_LD
+lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+])# _LT_LANG_CXX_CONFIG
+
+
+# AC_LIBTOOL_POSTDEP_PREDEP([TAGNAME])
+# ------------------------------------
+# Figure out "hidden" library dependencies from verbose
+# compiler output when linking a shared library.
+# Parse the compiler output and extract the necessary
+# objects, libraries and library flags.
+AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP],[
+# Dependencies to place before and after the object being linked:
+_LT_AC_TAGVAR(predep_objects, $1)=
+_LT_AC_TAGVAR(postdep_objects, $1)=
+_LT_AC_TAGVAR(predeps, $1)=
+_LT_AC_TAGVAR(postdeps, $1)=
+_LT_AC_TAGVAR(compiler_lib_search_path, $1)=
+
+dnl we can't use the lt_simple_compile_test_code here,
+dnl because it contains code intended for an executable,
+dnl not a library.  It's possible we should let each
+dnl tag define a new lt_????_link_test_code variable,
+dnl but it's only used here...
+m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
+int a;
+void foo (void) { a = 0; }
+_LT_EOF
+], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
+class Foo
+{
+public:
+  Foo (void) { a = 0; }
+private:
+  int a;
+};
+_LT_EOF
+], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
+      subroutine foo
+      implicit none
+      integer*4 a
+      a=0
+      return
+      end
+_LT_EOF
+], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
+public class foo {
+  private int a;
+  public void bar (void) {
+    a = 0;
+  }
+};
+_LT_EOF
+])
+dnl Parse the compiler output and extract the necessary
+dnl objects, libraries and library flags.
+if AC_TRY_EVAL(ac_compile); then
+  # Parse the compiler output and extract the necessary
+  # objects, libraries and library flags.
+
+  # Sentinel used to keep track of whether or not we are before
+  # the conftest object file.
+  pre_test_object_deps_done=no
+
+  # The `*' in the case matches for architectures that use `case' in
+  # $output_verbose_cmd can trigger glob expansion during the loop
+  # eval without this substitution.
+  output_verbose_link_cmd="`$echo \"X$output_verbose_link_cmd\" | $Xsed -e \"$no_glob_subst\"`"
+
+  for p in `eval $output_verbose_link_cmd`; do
+    case $p in
+
+    -L* | -R* | -l*)
+       # Some compilers place space between "-{L,R}" and the path.
+       # Remove the space.
+       if test $p = "-L" ||
+          test $p = "-R"; then
+	 prev=$p
+	 continue
+       else
+	 prev=
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+	 case $p in
+	 -L* | -R*)
+	   # Internal compiler library paths should come after those
+	   # provided the user.  The postdeps already come after the
+	   # user supplied libs so there is no need to process them.
+	   if test -z "$_LT_AC_TAGVAR(compiler_lib_search_path, $1)"; then
+	     _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
+	   else
+	     _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${_LT_AC_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
+	   fi
+	   ;;
+	 # The "-l" case would never come before the object being
+	 # linked, so don't bother handling this case.
+	 esac
+       else
+	 if test -z "$_LT_AC_TAGVAR(postdeps, $1)"; then
+	   _LT_AC_TAGVAR(postdeps, $1)="${prev}${p}"
+	 else
+	   _LT_AC_TAGVAR(postdeps, $1)="${_LT_AC_TAGVAR(postdeps, $1)} ${prev}${p}"
+	 fi
+       fi
+       ;;
+
+    *.$objext)
+       # This assumes that the test object file only shows up
+       # once in the compiler output.
+       if test "$p" = "conftest.$objext"; then
+	 pre_test_object_deps_done=yes
+	 continue
+       fi
+
+       if test "$pre_test_object_deps_done" = no; then
+	 if test -z "$_LT_AC_TAGVAR(predep_objects, $1)"; then
+	   _LT_AC_TAGVAR(predep_objects, $1)="$p"
+	 else
+	   _LT_AC_TAGVAR(predep_objects, $1)="$_LT_AC_TAGVAR(predep_objects, $1) $p"
+	 fi
+       else
+	 if test -z "$_LT_AC_TAGVAR(postdep_objects, $1)"; then
+	   _LT_AC_TAGVAR(postdep_objects, $1)="$p"
+	 else
+	   _LT_AC_TAGVAR(postdep_objects, $1)="$_LT_AC_TAGVAR(postdep_objects, $1) $p"
+	 fi
+       fi
+       ;;
+
+    *) ;; # Ignore the rest.
+
+    esac
+  done
+
+  # Clean up.
+  rm -f a.out a.exe
+else
+  echo "libtool.m4: error: problem compiling $1 test program"
+fi
+
+$rm -f confest.$objext
+
+case " $_LT_AC_TAGVAR(postdeps, $1) " in
+*" -lc "*) _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no ;;
+esac
+_LT_TAGDECL([], [predep_objects], [1],
+    [Dependencies to place before and after  the objects being linked to
+    create a shared library])
+_LT_TAGDECL([], [postdep_objects], [1])
+_LT_TAGDECL([], [predeps], [1])
+_LT_TAGDECL([], [postdeps], [1])
+_LT_TAGDECL([], [compiler_lib_search_path], [1],
+    [The library search path used internally by the compiler when linking
+    a shared library])
+])# AC_LIBTOOL_POSTDEP_PREDEP
+
+# _LT_LANG_F77_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for a Fortran 77 compiler are
+# suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_define([_LT_LANG_F77_CONFIG],
+[AC_REQUIRE([AC_PROG_F77])
+AC_LANG_PUSH(Fortran 77)
+
+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+_LT_AC_TAGVAR(allow_undefined_flag, $1)=
+_LT_AC_TAGVAR(always_export_symbols, $1)=no
+_LT_AC_TAGVAR(archive_expsym_cmds, $1)=
+_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_direct, $1)=no
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
+_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
+_LT_AC_TAGVAR(hardcode_minus_L, $1)=no
+_LT_AC_TAGVAR(hardcode_automatic, $1)=no
+_LT_AC_TAGVAR(inherit_rpath, $1)=no
+_LT_AC_TAGVAR(module_cmds, $1)=
+_LT_AC_TAGVAR(module_expsym_cmds, $1)=
+_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
+_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_AC_TAGVAR(no_undefined_flag, $1)=
+_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
+_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
+
+# Source file extension for f77 test sources.
+ac_ext=f
+
+# Object file extension for compiled f77 test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="      subroutine t\n      return\n      end\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="      program t\n      end\n"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${F77-"f77"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
+
+if test -n "$compiler"; then
+  AC_MSG_CHECKING([if libtool supports shared libraries])
+  AC_MSG_RESULT([$can_build_shared])
+
+  AC_MSG_CHECKING([whether to build shared libraries])
+  test "$can_build_shared" = "no" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case "$host_os" in
+  aix3*)
+    test "$enable_shared" = yes && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+  aix4* | aix5*)
+    test "$enable_shared" = yes && enable_static=no
+    ;;
+  esac
+  AC_MSG_RESULT([$enable_shared])
+
+  AC_MSG_CHECKING([whether to build static libraries])
+  # Make sure either enable_shared or enable_static is yes.
+  test "$enable_shared" = yes || enable_static=yes
+  AC_MSG_RESULT([$enable_static])
+
+  test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
+
+  _LT_AC_TAGVAR(GCC, $1)="$G77"
+  _LT_AC_TAGVAR(LD, $1)="$LD"
+
+  ## CAVEAT EMPTOR:
+  ## There is no encapsulation within the following macros, do not change
+  ## the running order or otherwise move them around unless you know exactly
+  ## what you are doing...
+  AC_LIBTOOL_PROG_COMPILER_PIC($1)
+  AC_LIBTOOL_PROG_CC_C_O($1)
+  AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+  AC_LIBTOOL_PROG_LD_SHLIBS($1)
+  AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+  AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+  AC_LIBTOOL_SYS_LIB_STRIP
+
+  _LT_CONFIG($1)
+fi
+
+AC_LANG_POP
+CC="$lt_save_CC"
+])# _LT_LANG_F77_CONFIG
+
+
+# _LT_LANG_GCJ_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Java Compiler compiler
+# are suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_define([_LT_LANG_GCJ_CONFIG],
+[AC_REQUIRE([LT_PROG_GCJ])
+AC_LANG_SAVE
+
+# Source file extension for Java test sources.
+ac_ext=java
+
+# Object file extension for compiled Java test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="class foo {}\n"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='public class conftest { public static void main(String[] argv) {}; }\n'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${GCJ-"gcj"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+
+# GCJ did not exist at the time GCC didn't implicitly link libc in.
+_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+  AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
+  AC_LIBTOOL_PROG_COMPILER_PIC($1)
+  AC_LIBTOOL_PROG_CC_C_O($1)
+  AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
+  AC_LIBTOOL_PROG_LD_SHLIBS($1)
+  AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
+  AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
+  AC_LIBTOOL_SYS_LIB_STRIP
+  AC_LIBTOOL_DLOPEN_SELF($1)
+
+  _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+CC="$lt_save_CC"
+])# _LT_LANG_GCJ_CONFIG
+
+
+# _LT_LANG_RC_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the Windows resource compiler
+# are suitably defined.  These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to `libtool'.
+m4_define([_LT_LANG_RC_CONFIG],
+[AC_REQUIRE([LT_PROG_RC])
+AC_LANG_SAVE
+
+# Source file extension for RC test sources.
+ac_ext=rc
+
+# Object file extension for compiled RC test sources.
+objext=o
+_LT_AC_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n'
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="$lt_simple_compile_test_code"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_AC_SYS_COMPILER
+
+# Allow CC to be a program name with arguments.
+lt_save_CC="$CC"
+CC=${RC-"windres"}
+compiler=$CC
+_LT_AC_TAGVAR(compiler, $1)=$CC
+_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
+
+if test -n "$compiler"; then
+  :
+  _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+CC="$lt_save_CC"
+])# _LT_LANG_RC_CONFIG
+
+
+AC_DEFUN([LT_PROG_GCJ],
+[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
+  [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
+    [AC_CHECK_TOOL(GCJ, gcj,)
+      test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
+      AC_SUBST(GCJFLAGS)])])dnl
+])
+AU_DEFUN([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
+
+AC_DEFUN([LT_PROG_RC],
+[AC_CHECK_TOOL(RC, windres,)
+])
+AU_DEFUN([LT_AC_PROG_RC], [LT_PROG_RC])
+
+
+# LT_AC_PROG_EGREP
+# ----------------
+# If we don't have a new enough Autoconf to choose the best grep
+# available, choose the one first in the user's PATH.
+AC_DEFUN([LT_AC_PROG_EGREP],
+[AC_REQUIRE([AC_PROG_EGREP])
+test -z "$GREP" && GREP=grep
+_LT_DECL([], [GREP], [1], [A grep program that handles long line])
+_LT_DECL([], [EGREP], [1], [An ERE matcher])
+])
+
+
+# LT_AC_PROG_SED
+# --------------
+# Check for a fully-functional sed program, that truncates
+# as few characters as possible.  Prefer GNU sed if found.
+AC_DEFUN([LT_AC_PROG_SED],
+[AC_PROG_SED
+test -z "$SED" && SED=sed
+_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
+_LT_DECL([], [Xsed], ["\$SED -e s/^X//"],
+    [Sed that helps us avoid accidentally triggering echo(1) options like -n])
+])# LT_AC_PROG_SED
+
+m4_ifndef([AC_PROG_SED], [
+############################################################
+# NOTE: This macro has been submitted for inclusion into   #
+#  GNU Autoconf as AC_PROG_SED.  When it is available in   #
+#  a released version of Autoconf we should remove this    #
+#  macro and use it instead.                               #
+############################################################
+
+m4_define([AC_PROG_SED],
+[AC_MSG_CHECKING([for a sed that does not truncate output])
+AC_CACHE_VAL(lt_cv_path_SED,
+[# Loop through the user's path and test for sed and gsed.
+# Then use that list of sed's as ones to test for truncation.
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for lt_ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
+        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
+      fi
+    done
+  done
+done
+lt_ac_max=0
+lt_ac_count=0
+# Add /usr/xpg4/bin/sed as it is typically found on Solaris
+# along with /bin/sed that truncates output.
+for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
+  test ! -f $lt_ac_sed && break
+  cat /dev/null > conftest.in
+  lt_ac_count=0
+  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
+  # Check for GNU sed and select it if it is found.
+  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
+    lt_cv_path_SED=$lt_ac_sed
+    break
+  fi
+  while true; do
+    cat conftest.in conftest.in >conftest.tmp
+    mv conftest.tmp conftest.in
+    cp conftest.in conftest.nl
+    echo >>conftest.nl
+    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
+    cmp -s conftest.out conftest.nl || break
+    # 10000 chars as input seems more than enough
+    test $lt_ac_count -gt 10 && break
+    lt_ac_count=`expr $lt_ac_count + 1`
+    if test $lt_ac_count -gt $lt_ac_max; then
+      lt_ac_max=$lt_ac_count
+      lt_cv_path_SED=$lt_ac_sed
+    fi
+  done
+done
+SED=$lt_cv_path_SED
+AC_SUBST([SED])
+])
+AC_MSG_RESULT([$SED])
+])#AC_PROG_SED
+])#m4_ifndef
diff --git a/libs/sigc++2/scripts/ltoptions.m4 b/libs/sigc++2/scripts/ltoptions.m4
new file mode 100644
index 0000000000..ea3089d330
--- /dev/null
+++ b/libs/sigc++2/scripts/ltoptions.m4
@@ -0,0 +1,358 @@
+# Helper functions for option handling.                    -*- Autoconf -*-
+# Written by Gary V. Vaughan <gary@gnu.org>
+
+# Copyright (C) 2004  Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+
+# serial 1
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
+
+
+# _LT_MANGLE_OPTION(NAME)
+# -----------------------
+m4_define([_LT_MANGLE_OPTION],
+[[_LT_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
+
+
+# _LT_SET_OPTION(NAME)
+# ------------------------------
+# Set option NAME.  Other NAMEs are saved as a flag.
+m4_define([_LT_SET_OPTION], [m4_define(_LT_MANGLE_OPTION([$1]))])
+
+
+# _LT_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+m4_define([_LT_IF_OPTION],
+[m4_ifdef(_LT_MANGLE_OPTION([$1]), [$2], [$3])])
+
+
+# _LT_UNLESS_OPTIONS(OPTIONS, IF-NOT-SET)
+# ---------------------------------------
+# Execute IF-NOT-SET if all OPTIONS are not set.
+m4_define([_LT_UNLESS_OPTIONS],
+[AC_FOREACH([_LT_Option], [$1],
+	    [m4_ifdef(_LT_MANGLE_OPTION(_LT_Option),
+		      [m4_define([$0_found])])])[]dnl
+m4_ifdef([$0_found], [m4_undefine([$0_found])], [$2
+])[]dnl
+])
+
+
+# _LT_SET_OPTIONS(OPTIONS)
+# ------------------------
+# OPTIONS is a space-separated list of Automake options.
+# If any OPTION has a handler macro declared with LT_OPTION_DEFINE,
+# despatch to that macro; otherwise complain about the unknown option
+# and exit.
+m4_define([_LT_SET_OPTIONS],
+[AC_FOREACH([_LT_Option], [$1],
+    [_LT_SET_OPTION(_LT_Option)
+    m4_ifdef(_LT_MANGLE_DEFUN(_LT_Option),
+		_LT_MANGLE_DEFUN(_LT_Option),
+	[m4_fatal([Unknown option `]_LT_Option[' to LT][_INIT_LIBTOOL])])
+    ])dnl
+dnl
+dnl Simply set some default values (i.e off) if boolean options were not
+dnl specified:
+_LT_UNLESS_OPTIONS([dlopen], enable_dlopen=no)
+_LT_UNLESS_OPTIONS([win32-dll], enable_win32_dll=no)
+dnl
+dnl If no reference was made to various pairs of opposing options, then
+dnl we run the default mode handler for the pair.  For example, if neither
+dnl `shared' nor `disable-shared' was passed, we enable building of shared
+dnl archives by default:
+_LT_UNLESS_OPTIONS([shared disable-shared], [_LT_ENABLE_SHARED])
+_LT_UNLESS_OPTIONS([static disable-static], [_LT_ENABLE_STATIC])
+_LT_UNLESS_OPTIONS([pic-only no-pic], [_LT_WITH_PIC])
+_LT_UNLESS_OPTIONS([fast-install disable-fast-install],
+		   [_LT_ENABLE_FAST_INSTALL])
+])# _LT_SET_OPTIONS
+
+
+## ----------------------------------------- ##
+## Macros to handle LT_INIT_LIBTOOL options. ##
+## ----------------------------------------- ##
+
+m4_define([_LT_MANGLE_DEFUN],
+[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1]), [[^A-Z0-9_]], [_])])
+
+
+# LT_OPTION_DEFINE(NAME, CODE)
+# ----------------------------
+m4_define([LT_OPTION_DEFINE],
+[m4_define(_LT_MANGLE_DEFUN([$1]), [$2])[]dnl
+])# LT_OPTION_DEFINE
+
+
+# dlopen
+# ------
+LT_OPTION_DEFINE([dlopen], [enable_dlopen=yes])
+
+AU_DEFUN([AC_LIBTOOL_DLOPEN],
+[_LT_SET_OPTION([dlopen])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `dlopen' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+
+# win32-dll
+# ---------
+# Declare package support for building win32 dll's.
+LT_OPTION_DEFINE([win32-dll],
+[enable_win32_dll=yes
+
+case $host in
+*-*-cygwin* | *-*-mingw* | *-*-pw32*)
+  AC_CHECK_TOOL(AS, as, false)
+  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
+  AC_CHECK_TOOL(OBJDUMP, objdump, false)
+  ;;
+esac
+
+test -z "$AS" && AS=as
+_LT_DECL([], [AS],      [0], [Assembler program])dnl
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+_LT_DECL([], [DLLTOOL], [0], [DLL creation program])dnl
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+_LT_DECL([], [OBJDUMP], [0], [Object dumper program])dnl
+])# win32-dll
+
+AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
+[_LT_SET_OPTION([win32-dll])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `win32-dll' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+
+# _LT_ENABLE_SHARED([DEFAULT])
+# ----------------------------
+# implement the --enable-shared flag, and supports the `shared' and
+# `disable-shared' LT_INIT_LIBTOOL options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_SHARED],
+[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([shared],
+    [AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
+	[build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
+
+    _LT_DECL([build_libtool_libs], [enable_shared], [0],
+	[Whether or not to build shared libraries])
+])# _LT_ENABLE_SHARED
+
+LT_OPTION_DEFINE([shared], [_LT_ENABLE_SHARED([yes])])
+LT_OPTION_DEFINE([disable-shared], [_LT_ENABLE_SHARED([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_SHARED],
+[_LT_SET_OPTION([shared])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `shared' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+AU_DEFUN([AM_ENABLE_SHARED],
+[_LT_SET_OPTION([shared])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `shared' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_SHARED],
+[_LT_SET_OPTION([disable-shared])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-shared' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+AU_DEFUN([AM_DISABLE_SHARED],
+[_LT_SET_OPTION([disable-shared])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-shared' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+
+# _LT_ENABLE_STATIC([DEFAULT])
+# ----------------------------
+# implement the --enable-static flag, and support the `static' and
+# `disable-static' LT_INIT_LIBTOOL options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_STATIC],
+[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([static],
+    [AC_HELP_STRING([--enable-static@<:@=PKGS@:>@],
+	[build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
+
+    _LT_DECL([build_old_libs], [enable_static], [0],
+	[Whether or not to build static libraries])
+])# _LT_ENABLE_STATIC
+
+LT_OPTION_DEFINE([static], [_LT_ENABLE_STATIC([yes])])
+LT_OPTION_DEFINE([disable-static], [_LT_ENABLE_STATIC([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_STATIC],
+[_LT_SET_OPTION([static])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `static' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+AU_DEFUN([AM_ENABLE_STATIC],
+[_LT_SET_OPTION([static])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `static' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_STATIC],
+[_LT_SET_OPTION([disable-static])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-static' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+AU_DEFUN([AM_DISABLE_STATIC],
+[_LT_SET_OPTION([disable-static])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-static' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+
+# _LT_ENABLE_FAST_INSTALL([DEFAULT])
+# ----------------------------------
+# implement the --enable-fast-install flag, and support the `fast-install'
+# and `disable-fast-install' LT_INIT_LIBTOOL options.
+# DEFAULT is either `yes' or `no'.  If omitted, it defaults to `yes'.
+m4_define([_LT_ENABLE_FAST_INSTALL],
+[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
+AC_ARG_ENABLE([fast-install],
+    [AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
+    [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
+    [p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
+      for pkg in $enableval; do
+	IFS="$lt_save_ifs"
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS="$lt_save_ifs"
+      ;;
+    esac],
+    [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
+
+_LT_DECL([fast_install], [enable_fast_install], [0],
+	 [Whether or not to optimize for fast installation])dnl
+])# _LT_ENABLE_FAST_INSTALL
+
+LT_OPTION_DEFINE([fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
+LT_OPTION_DEFINE([disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
+
+# Old names:
+AU_DEFUN([AC_ENABLE_FAST_INSTALL],
+[_LT_SET_OPTION([fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `fast-install' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+AU_DEFUN([AC_DISABLE_FAST_INSTALL],
+[_LT_SET_OPTION([disable-fast-install])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you put
+the `disable-fast-install' option into LT_LIBTOOL_INIT's first parameter.])
+])
+
+
+# _LT_WITH_PIC([MODE])
+# --------------------
+# implement the --with-pic flag, and support the `pic-only' and `no-pic'
+# LT_INIT_LIBTOOL options.
+# MODE is either `yes' or `no'.  If omitted, it defaults to `both'.
+m4_define([_LT_WITH_PIC],
+[AC_ARG_WITH([pic],
+    [AC_HELP_STRING([--with-pic],
+	[try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
+    [pic_mode="$withval"],
+    [pic_mode=default])
+
+test -z "$pic_mode" && pic_mode=m4_if($#, 1, $1, default)
+
+_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
+])# _LT_WITH_PIC
+
+LT_OPTION_DEFINE([pic-only], [_LT_WITH_PIC([yes])])
+LT_OPTION_DEFINE([no-pic], [_LT_WITH_PIC([no])])
+
+# Old name:
+AU_DEFUN([AC_LIBTOOL_PIC_MODE],
+[_LT_SET_OPTION([pic-only])
+AC_DIAGNOSE([obsolete],
+[$0: Remove this warning and the call to _LT_SET_OPTION when you
+put the `pic-only' option into LT_LIBTOOL_INIT's first parameter.])
+])
diff --git a/libs/sigc++2/scripts/ltsugar.m4 b/libs/sigc++2/scripts/ltsugar.m4
new file mode 100644
index 0000000000..c0f31aa63d
--- /dev/null
+++ b/libs/sigc++2/scripts/ltsugar.m4
@@ -0,0 +1,115 @@
+# ltsugar.m4 -- libtool m4 base layer.                         -*-Autoconf-*-
+#
+# Copyright (C) 2004 Free Software Foundation, Inc.
+# Written by Gary V. Vaughan.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program 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
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# serial 1
+
+# This is to help aclocal find these macros, as it can't see m4_define.
+AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
+
+
+# lt_join(SEP, ARG1, [ARG2...])
+# -----------------------------
+# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
+# associated separator.
+m4_define([lt_join],
+[m4_case([$#],
+	 [0], [m4_fatal([$0: too few arguments: $#])],
+	 [1], [],
+	 [2], [[$2]],
+	 [m4_ifval([$2],
+		   [m4_ifval([$3],
+			     [[$2][$1][]$0([$1], m4_shiftn(2, $@))],
+		       [m4_if([$#], [3],
+			      [$2],
+			   [$0([$1], [$2], m4_shiftn(3, $@))])])],
+	      [$0([$1], m4_shiftn(2, $@))])])[]dnl
+])
+
+
+# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
+# ----------------------------------------------------------
+# Produce a SEP delimited list of all paired combinations of elements of
+# PREFIX-LIST with SUFFIX1 through SUFFIXn.  Each element of the list
+# has the form PREFIXmINFIXSUFFIXn.
+m4_define([lt_combine],
+[m4_if([$2], [[]], [],
+       [lt_join(m4_quote(m4_default([$1], [, ])),
+		_$0([$1], m4_car($2)[$3], m4_shiftn(3, $@)),
+		$0([$1], m4_cdr($2), m4_shiftn(2, $@)))])])
+m4_define([_lt_combine],
+[m4_if([$3], [], [],
+       [lt_join(m4_quote(m4_default([$1], [, ])),
+		[$2$3],
+		$0([$1], [$2], m4_shiftn(3, $@)))])[]dnl
+])
+
+
+# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
+# -----------------------------------------------------------------------
+# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
+# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
+m4_define([lt_if_append_uniq],
+[m4_ifdef([$1],
+	[m4_bmatch($3[]m4_defn([$1])$3, $3[]m4_re_escape([$2])$3,
+		[$5],
+	    [m4_append([$1], [$2], [$3])$4])],
+    [m4_append([$1], [$2], [$3])$4])])
+
+
+# lt_dict_add(DICT, KEY, VALUE)
+# -----------------------------
+m4_define([lt_dict_add],
+[m4_define([$1($2)], [$4])])
+
+
+# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
+# --------------------------------------------
+m4_define([lt_dict_add_subkey],
+[m4_define([$1($2:$3)], [$4])])
+
+
+# lt_dict_fetch(DICT, KEY, [SUBKEY])
+# ----------------------------------
+m4_define([lt_dict_fetch],
+[m4_ifval([$3],
+	m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
+    m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
+
+
+# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
+# -----------------------------------------------------------------
+m4_define([lt_if_dict_fetch],
+[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
+	[$5],
+    [$6])])
+
+
+# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
+# ------------------------------------------------------------
+m4_define([lt_dict_filter],
+[m4_if([$5], [], [],
+  [lt_join(m4_quote(m4_default([$4], [[, ]])),
+	   m4_quote(lt_if_dict_fetch([$1], [$5], [$2], [$3], [$5])),
+	   m4_quote($0([$1], [$2], [$3], [$4], m4_shiftn(5, $@))))])dnl
+])
diff --git a/libs/sigc++2/scripts/ltversion.m4 b/libs/sigc++2/scripts/ltversion.m4
new file mode 100644
index 0000000000..8b8db37ad4
--- /dev/null
+++ b/libs/sigc++2/scripts/ltversion.m4
@@ -0,0 +1,15 @@
+# ltversion.m4 -- version numbers			-*- Autoconf -*-
+# Generated from ltversion.in; do not edit by hand.
+
+# serial 1467
+# This file is part of GNU Libtool
+
+m4_define([LT_PACKAGE_VERSION], [])
+m4_define([LT_PACKAGE_REVISION], [1.1467])
+
+AC_DEFUN([LTVERSION_VERSION],
+[macro_version=''
+macro_revision='1.1467'
+_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
+_LT_DECL(, macro_revision, 0)
+])
diff --git a/libs/sigc++2/sigc++/.cvsignore b/libs/sigc++2/sigc++/.cvsignore
new file mode 100644
index 0000000000..6f2fbbd6d8
--- /dev/null
+++ b/libs/sigc++2/sigc++/.cvsignore
@@ -0,0 +1,4 @@
+Makefile
+Makefile.in
+.deps
+*.os
diff --git a/libs/sigc++2/sigc++/Makefile.am b/libs/sigc++2/sigc++/Makefile.am
index b5793f2fd8..6f9af23e0b 100644
--- a/libs/sigc++2/sigc++/Makefile.am
+++ b/libs/sigc++2/sigc++/Makefile.am
@@ -1,10 +1,9 @@
 # Base (./)
 base_m4 = template.macros.m4 signal.h.m4 slot.h.m4 method_slot.h.m4 \
-	  object_slot.h.m4 class_slot.h.m4 hide.h.m4 retype.h.m4 \
-	  limit_reference.h.m4
+	  object_slot.h.m4 class_slot.h.m4 hide.h.m4 retype.h.m4
 base_built_cc =
 base_built_h = signal.h slot.h method_slot.h \
-	       object_slot.h class_slot.h hide.h retype.h limit_reference.h
+	       object_slot.h class_slot.h hide.h retype.h
 
 signal.cc : signal.h signal_base.h functors/slot.h functors/slot_base.h functors/mem_fun.h functors/functor_trait.h
 
@@ -58,22 +57,15 @@ nobase_library_include_HEADERS = $(sigc_m4) $(sigc_built_h) \
   functors/functors.h \
   functors/slot_base.h \
   adaptors/adaptors.h \
-  adaptors/bound_argument.h \
   adaptors/lambda/lambda.h
 
-# Support for DLL on cygwin/mingw using libtool > 1.4
-if PLATFORM_WIN32
-win32_dlls_ldflags = -no-undefined -Wl,--export-all-symbols
-else
-win32_dlls_ldflags =
-endif
-
 # build the library
-lib_LTLIBRARIES = libsigc-2.0.la
-libsigc_2_0_la_SOURCES = signal.cc signal_base.cc trackable.cc connection.cc \
+#lib_LTLIBRARIES = libsigc-2.0.la
+#libsigc_2_0_la_SOURCES = signal.cc signal_base.cc trackable.cc connection.cc \
                          functors/slot.cc functors/slot_base.cc \
 			 adaptors/lambda/lambda.cc
-libsigc_2_0_la_LDFLAGS  = $(win32_dlls_ldflags)
+#libsigc_2_0_la_LDFLAGS  = 
+
 BUILT_SOURCES = $(sigc_built_h) $(sigc_built_cc)
 
 CLEANFILES = build-subdirs-stamp
diff --git a/libs/sigc++2/sigc++/adaptors/adaptor_trait.h b/libs/sigc++2/sigc++/adaptors/adaptor_trait.h
index b4ae6c5621..8b618d7450 100644
--- a/libs/sigc++2/sigc++/adaptors/adaptor_trait.h
+++ b/libs/sigc++2/sigc++/adaptors/adaptor_trait.h
@@ -251,7 +251,6 @@ adaptor_functor<T_functor>::operator()() const
   { return functor_(); }
 
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::adaptor_functor performs a functor
  * on the functor stored in the sigc::adaptor_functor object.
@@ -262,9 +261,7 @@ template <class T_action, class T_functor>
 void visit_each(const T_action& _A_action,
                 const adaptor_functor<T_functor>& _A_target)
 {
-  //The extra sigc:: prefix avoids ambiguity in some strange
-  //situations.
-  sigc::visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.functor_);
 }
 
 
diff --git a/libs/sigc++2/sigc++/adaptors/bind.h b/libs/sigc++2/sigc++/adaptors/bind.h
index a96bbcd66a..180a5f26e7 100644
--- a/libs/sigc++2/sigc++/adaptors/bind.h
+++ b/libs/sigc++2/sigc++/adaptors/bind.h
@@ -3,7 +3,6 @@
 #ifndef _SIGC_ADAPTORS_MACROS_BINDHM4_
 #define _SIGC_ADAPTORS_MACROS_BINDHM4_
 #include <sigc++/adaptors/adaptor_trait.h>
-#include <sigc++/adaptors/bound_argument.h>
 
 namespace sigc { 
 
@@ -141,24 +140,20 @@ struct bind_functor;
  * @ingroup bind
  */
 template <class T_functor, class T_bound>
-struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : public adapts<T_functor>
+struct bind_functor<0, T_functor, T_bound> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
   typedef typename adaptor_type::result_type  result_type;
 
   /** Invokes the wrapped functor passing on the bound argument only.
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the 1th argument.
@@ -168,16 +163,16 @@ struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass>
-        (bound_.invoke(), _A_arg1);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass>
+        (bound_, _A_arg1);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass>
-        (bound_.invoke(), _A_arg1);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass>
+        (bound_, _A_arg1);
     }
   #endif
     
@@ -190,16 +185,16 @@ struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (bound_, _A_arg1, _A_arg2);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+        (bound_, _A_arg1, _A_arg2);
     }
   #endif
     
@@ -213,16 +208,16 @@ struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3);
     }
   #endif
     
@@ -237,16 +232,16 @@ struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4);
     }
   #endif
     
@@ -262,16 +257,16 @@ struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
     }
   #endif
     
@@ -288,16 +283,16 @@ struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
     }
   #endif
     
@@ -310,33 +305,34 @@ struct bind_functor<0, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_bound> bound_;
+  T_bound bound_;
 };
 
+template <class T_functor, class T_bound>
+typename bind_functor<0, T_functor, T_bound>::result_type
+bind_functor<0, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
 /** Adaptor that binds an argument to the wrapped functor.
  * This template specialization fixes the 2th argument of the wrapped functor.
  *
  * @ingroup bind
  */
 template <class T_functor, class T_bound>
-struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : public adapts<T_functor>
+struct bind_functor<1, T_functor, T_bound> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
   typedef typename adaptor_type::result_type  result_type;
 
   /** Invokes the wrapped functor passing on the bound argument only.
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the 2th argument.
@@ -346,16 +342,16 @@ struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1, bound_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1, bound_);
     }
   #endif
     
@@ -368,16 +364,16 @@ struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass>
+        (_A_arg1, bound_, _A_arg2);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass>
+        (_A_arg1, bound_, _A_arg2);
     }
   #endif
     
@@ -391,16 +387,16 @@ struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3);
     }
   #endif
     
@@ -415,16 +411,16 @@ struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4);
     }
   #endif
     
@@ -440,16 +436,16 @@ struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
     }
   #endif
     
@@ -466,16 +462,16 @@ struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
     }
   #endif
     
@@ -488,33 +484,34 @@ struct bind_functor<1, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_bound> bound_;
+  T_bound bound_;
 };
 
+template <class T_functor, class T_bound>
+typename bind_functor<1, T_functor, T_bound>::result_type
+bind_functor<1, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
 /** Adaptor that binds an argument to the wrapped functor.
  * This template specialization fixes the 3th argument of the wrapped functor.
  *
  * @ingroup bind
  */
 template <class T_functor, class T_bound>
-struct bind_functor<2, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : public adapts<T_functor>
+struct bind_functor<2, T_functor, T_bound> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
   typedef typename adaptor_type::result_type  result_type;
 
   /** Invokes the wrapped functor passing on the bound argument only.
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the 3th argument.
@@ -525,16 +522,16 @@ struct bind_functor<2, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2, bound_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2, bound_);
     }
   #endif
     
@@ -548,16 +545,16 @@ struct bind_functor<2, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3);
     }
   #endif
     
@@ -572,16 +569,16 @@ struct bind_functor<2, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4);
     }
   #endif
     
@@ -597,16 +594,16 @@ struct bind_functor<2, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5);
     }
   #endif
     
@@ -623,16 +620,16 @@ struct bind_functor<2, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
     }
   #endif
     
@@ -645,33 +642,34 @@ struct bind_functor<2, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_bound> bound_;
+  T_bound bound_;
 };
 
+template <class T_functor, class T_bound>
+typename bind_functor<2, T_functor, T_bound>::result_type
+bind_functor<2, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
 /** Adaptor that binds an argument to the wrapped functor.
  * This template specialization fixes the 4th argument of the wrapped functor.
  *
  * @ingroup bind
  */
 template <class T_functor, class T_bound>
-struct bind_functor<3, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : public adapts<T_functor>
+struct bind_functor<3, T_functor, T_bound> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
   typedef typename adaptor_type::result_type  result_type;
 
   /** Invokes the wrapped functor passing on the bound argument only.
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the 4th argument.
@@ -683,16 +681,16 @@ struct bind_functor<3, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_);
     }
   #endif
     
@@ -707,16 +705,16 @@ struct bind_functor<3, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4);
     }
   #endif
     
@@ -732,16 +730,16 @@ struct bind_functor<3, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5);
     }
   #endif
     
@@ -758,16 +756,16 @@ struct bind_functor<3, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5, _A_arg6);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5, _A_arg6);
     }
   #endif
     
@@ -780,33 +778,34 @@ struct bind_functor<3, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_bound> bound_;
+  T_bound bound_;
 };
 
+template <class T_functor, class T_bound>
+typename bind_functor<3, T_functor, T_bound>::result_type
+bind_functor<3, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
 /** Adaptor that binds an argument to the wrapped functor.
  * This template specialization fixes the 5th argument of the wrapped functor.
  *
  * @ingroup bind
  */
 template <class T_functor, class T_bound>
-struct bind_functor<4, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : public adapts<T_functor>
+struct bind_functor<4, T_functor, T_bound> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
   typedef typename adaptor_type::result_type  result_type;
 
   /** Invokes the wrapped functor passing on the bound argument only.
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the 5th argument.
@@ -819,16 +818,16 @@ struct bind_functor<4, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_);
     }
   #endif
     
@@ -844,16 +843,16 @@ struct bind_functor<4, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5);
     }
   #endif
     
@@ -870,16 +869,16 @@ struct bind_functor<4, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5, _A_arg6);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5, _A_arg6);
     }
   #endif
     
@@ -892,33 +891,34 @@ struct bind_functor<4, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_bound> bound_;
+  T_bound bound_;
 };
 
+template <class T_functor, class T_bound>
+typename bind_functor<4, T_functor, T_bound>::result_type
+bind_functor<4, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
 /** Adaptor that binds an argument to the wrapped functor.
  * This template specialization fixes the 6th argument of the wrapped functor.
  *
  * @ingroup bind
  */
 template <class T_functor, class T_bound>
-struct bind_functor<5, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : public adapts<T_functor>
+struct bind_functor<5, T_functor, T_bound> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg6>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>::type type; };
   typedef typename adaptor_type::result_type  result_type;
 
   /** Invokes the wrapped functor passing on the bound argument only.
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the 6th argument.
@@ -932,16 +932,16 @@ struct bind_functor<5, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_);
     }
   #endif
     
@@ -958,16 +958,16 @@ struct bind_functor<5, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke(), _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_, _A_arg6);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg6>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke(), _A_arg6);
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_, _A_arg6);
     }
   #endif
     
@@ -980,33 +980,34 @@ struct bind_functor<5, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_bound> bound_;
+  T_bound bound_;
 };
 
+template <class T_functor, class T_bound>
+typename bind_functor<5, T_functor, T_bound>::result_type
+bind_functor<5, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+
 /** Adaptor that binds an argument to the wrapped functor.
  * This template specialization fixes the 7th argument of the wrapped functor.
  *
  * @ingroup bind
  */
 template <class T_functor, class T_bound>
-struct bind_functor<6, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : public adapts<T_functor>
+struct bind_functor<6, T_functor, T_bound> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>::type type; };
   typedef typename adaptor_type::result_type  result_type;
 
   /** Invokes the wrapped functor passing on the bound argument only.
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * bound_ is passed as the 7th argument.
@@ -1021,16 +1022,16 @@ struct bind_functor<6, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_);
     }
   #endif
     
@@ -1043,11 +1044,14 @@ struct bind_functor<6, T_functor, T_bound, nil_,nil_,nil_,nil_,nil_,nil_> : publ
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_bound> bound_;
+  T_bound bound_;
 };
 
+template <class T_functor, class T_bound>
+typename bind_functor<6, T_functor, T_bound>::result_type
+bind_functor<6, T_functor, T_bound>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -1068,29 +1072,29 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_functor, class T_type1>
-struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<3, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>::type type; };
 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
@@ -1104,11 +1108,7 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass> (bound1_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * The last 1 argument(s) are fixed.
@@ -1118,16 +1118,16 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1, bound1_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1, bound1_);
     }
   #endif
     
@@ -1140,16 +1140,16 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2, bound1_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2, bound1_);
     }
   #endif
     
@@ -1163,16 +1163,16 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_);
     }
   #endif
     
@@ -1187,16 +1187,16 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_);
     }
   #endif
     
@@ -1212,16 +1212,16 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_);
     }
   #endif
     
@@ -1238,16 +1238,16 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_);
     }
   #endif
     
@@ -1260,11 +1260,14 @@ struct bind_functor<-1, T_functor, T_type1, nil_, nil_, nil_, nil_, nil_, nil_>
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_type1> bound1_;
+  T_type1 bound1_;
 };
 
+template <class T_functor, class T_type1>
+typename bind_functor<-1, T_functor, T_type1>::result_type
+bind_functor<-1, T_functor, T_type1>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass> (bound1_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -1285,26 +1288,26 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_functor, class T_type1,class T_type2>
-struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil_> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1,T_type2> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<3, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
@@ -1318,11 +1321,7 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass> (bound1_.invoke(),bound2_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * The last 2 argument(s) are fixed.
@@ -1332,16 +1331,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1, bound1_,bound2_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1, bound1_,bound2_);
     }
   #endif
     
@@ -1354,16 +1353,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_);
     }
   #endif
     
@@ -1377,16 +1376,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_);
     }
   #endif
     
@@ -1401,16 +1400,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_);
     }
   #endif
     
@@ -1426,16 +1425,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_,bound2_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke(),bound2_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_,bound2_);
     }
   #endif
     
@@ -1448,12 +1447,15 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, nil_, nil_, nil_, nil_, nil
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_type1> bound1_;
-  bound_argument<T_type2> bound2_;
+  T_type1 bound1_;
+  T_type2 bound2_;
 };
 
+template <class T_functor, class T_type1,class T_type2>
+typename bind_functor<-1, T_functor, T_type1,T_type2>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass> (bound1_,bound2_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -1475,23 +1477,23 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_functor, class T_type1,class T_type2,class T_type3>
-struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil_, nil_, nil_, nil_> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
@@ -1505,11 +1507,7 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil_, nil_, nil_,
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * The last 3 argument(s) are fixed.
@@ -1519,16 +1517,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil_, nil_, nil_,
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_);
     }
   #endif
     
@@ -1541,16 +1539,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil_, nil_, nil_,
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_);
     }
   #endif
     
@@ -1564,16 +1562,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil_, nil_, nil_,
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_);
     }
   #endif
     
@@ -1588,16 +1586,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil_, nil_, nil_,
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_,bound3_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
+        (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_,bound3_);
     }
   #endif
     
@@ -1610,13 +1608,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil_, nil_, nil_,
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_type1> bound1_;
-  bound_argument<T_type2> bound2_;
-  bound_argument<T_type3> bound3_;
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
 };
 
+template <class T_functor, class T_type1,class T_type2,class T_type3>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass> (bound1_,bound2_,bound3_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -1639,20 +1640,20 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4>
-struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil_, nil_, nil_> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
@@ -1666,11 +1667,7 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil_, nil
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * The last 4 argument(s) are fixed.
@@ -1680,16 +1677,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil_, nil
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_);
     }
   #endif
     
@@ -1702,16 +1699,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil_, nil
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_);
     }
   #endif
     
@@ -1725,16 +1722,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil_, nil
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_,bound4_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
-        (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
+        (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_,bound4_);
     }
   #endif
     
@@ -1747,14 +1744,17 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil_, nil
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_type1> bound1_;
-  bound_argument<T_type2> bound2_;
-  bound_argument<T_type3> bound3_;
-  bound_argument<T_type4> bound4_;
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
 };
 
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass> (bound1_,bound2_,bound3_,bound4_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -1778,17 +1778,17 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
-struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, nil_, nil_> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>::type type; };
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>::type type; };
 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
@@ -1802,11 +1802,7 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * The last 5 argument(s) are fixed.
@@ -1816,16 +1812,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_);
     }
   #endif
     
@@ -1838,16 +1834,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_,bound5_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
-        (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
+        (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_,bound5_);
     }
   #endif
     
@@ -1860,15 +1856,18 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_type1> bound1_;
-  bound_argument<T_type2> bound2_;
-  bound_argument<T_type3> bound3_;
-  bound_argument<T_type4> bound4_;
-  bound_argument<T_type5> bound5_;
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
+  T_type5 bound5_;
 };
 
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -1893,14 +1892,14 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
-struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, nil_> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>::type type; };
 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
@@ -1914,11 +1913,7 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke());
-  }
+  operator()();
 
   /** Invokes the wrapped functor passing on the arguments.
    * The last 6 argument(s) are fixed.
@@ -1928,16 +1923,16 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_,bound6_);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_arg1)
-    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass>
-        (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke());
+    { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>
+        (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_,bound6_);
     }
   #endif
     
@@ -1950,16 +1945,19 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_type1> bound1_;
-  bound_argument<T_type2> bound2_;
-  bound_argument<T_type3> bound3_;
-  bound_argument<T_type4> bound4_;
-  bound_argument<T_type5> bound5_;
-  bound_argument<T_type6> bound6_;
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
+  T_type5 bound5_;
+  T_type6 bound6_;
 };
 
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_,bound6_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -1985,14 +1983,14 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
-struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7> : public adapts<T_functor>
 {
   typedef typename adapts<T_functor>::adaptor_type adaptor_type;
 
 #ifndef DOXYGEN_SHOULD_SKIP_THIS
   template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   struct deduce_result_type_internal
-    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass,typename type_trait<typename unwrap_reference<T_type7>::type>::pass>::type type; };
+    { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass,typename type_trait<T_type7>::pass>::type type; };
 #endif /*DOXYGEN_SHOULD_SKIP_THIS*/
 
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
@@ -2006,11 +2004,7 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
    * @return The return value of the functor invocation.
    */
   result_type
-  operator()()
-  {
-    //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
-    return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass,typename type_trait<typename unwrap_reference<T_type7>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke(),bound7_.invoke());
-  }
+  operator()();
 
   /** Constructs a bind_functor object that binds an argument to the passed functor.
    * @param _A_functor Functor to invoke from operator()().
@@ -2021,17 +2015,20 @@ struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5,
     {}
 
   /// The argument bound to the functor.
-  bound_argument<T_type1> bound1_;
-  bound_argument<T_type2> bound2_;
-  bound_argument<T_type3> bound3_;
-  bound_argument<T_type4> bound4_;
-  bound_argument<T_type5> bound5_;
-  bound_argument<T_type6> bound6_;
-  bound_argument<T_type7> bound7_;
+  T_type1 bound1_;
+  T_type2 bound2_;
+  T_type3 bound3_;
+  T_type4 bound4_;
+  T_type5 bound5_;
+  T_type6 bound6_;
+  T_type7 bound7_;
 };
 
+template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
+typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::result_type
+bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
+  { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass,typename type_trait<T_type7>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_,bound6_,bound7_); }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_functor performs a functor on the
  * functor and on the object instances stored in the sigc::bind_functor object.
@@ -2064,10 +2061,10 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <int I_location, class T_bound1, class T_functor>
-inline bind_functor<I_location, T_functor, T_bound1>
+inline bind_functor<I_location, T_functor, typename unwrap_reference<T_bound1>::type>
 bind(const T_functor& _A_func, T_bound1 _A_b1)
 { 
-  return bind_functor<I_location, T_functor, T_bound1>
+  return bind_functor<I_location, T_functor, typename unwrap_reference<T_bound1>::type>
            (_A_func, _A_b1);
 }
 
@@ -2082,10 +2079,10 @@ bind(const T_functor& _A_func, T_bound1 _A_b1)
  */
 template <class T_type1, class T_functor>
 inline bind_functor<-1, T_functor,
-                    T_type1>
+                    typename unwrap_reference<T_type1>::type>
 bind(const T_functor& _A_func, T_type1 _A_b1)
 { return bind_functor<-1, T_functor,
-                    T_type1>
+                    typename unwrap_reference<T_type1>::type>
                     (_A_func, _A_b1);
 }
 
@@ -2101,12 +2098,12 @@ bind(const T_functor& _A_func, T_type1 _A_b1)
  */
 template <class T_type1,class T_type2, class T_functor>
 inline bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type>
 bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2)
 { return bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type>
                     (_A_func, _A_b1,_A_b2);
 }
 
@@ -2123,14 +2120,14 @@ bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2)
  */
 template <class T_type1,class T_type2,class T_type3, class T_functor>
 inline bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type>
 bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3)
 { return bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type>
                     (_A_func, _A_b1,_A_b2,_A_b3);
 }
 
@@ -2148,16 +2145,16 @@ bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3)
  */
 template <class T_type1,class T_type2,class T_type3,class T_type4, class T_functor>
 inline bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type>
 bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4)
 { return bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type>
                     (_A_func, _A_b1,_A_b2,_A_b3,_A_b4);
 }
 
@@ -2176,18 +2173,18 @@ bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4
  */
 template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5, class T_functor>
 inline bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4,
-                    T_type5>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type>
 bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5)
 { return bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4,
-                    T_type5>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type>
                     (_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5);
 }
 
@@ -2207,20 +2204,20 @@ bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4
  */
 template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6, class T_functor>
 inline bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4,
-                    T_type5,
-                    T_type6>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type>
 bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5,T_type6 _A_b6)
 { return bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4,
-                    T_type5,
-                    T_type6>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type>
                     (_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5,_A_b6);
 }
 
@@ -2241,22 +2238,22 @@ bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4
  */
 template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7, class T_functor>
 inline bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4,
-                    T_type5,
-                    T_type6,
-                    T_type7>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type,
+                    typename unwrap_reference<T_type7>::type>
 bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5,T_type6 _A_b6,T_type7 _A_b7)
 { return bind_functor<-1, T_functor,
-                    T_type1,
-                    T_type2,
-                    T_type3,
-                    T_type4,
-                    T_type5,
-                    T_type6,
-                    T_type7>
+                    typename unwrap_reference<T_type1>::type,
+                    typename unwrap_reference<T_type2>::type,
+                    typename unwrap_reference<T_type3>::type,
+                    typename unwrap_reference<T_type4>::type,
+                    typename unwrap_reference<T_type5>::type,
+                    typename unwrap_reference<T_type6>::type,
+                    typename unwrap_reference<T_type7>::type>
                     (_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5,_A_b6,_A_b7);
 }
 
diff --git a/libs/sigc++2/sigc++/adaptors/bind_return.h b/libs/sigc++2/sigc++/adaptors/bind_return.h
index e330d78d19..40e3524090 100644
--- a/libs/sigc++2/sigc++/adaptors/bind_return.h
+++ b/libs/sigc++2/sigc++/adaptors/bind_return.h
@@ -3,7 +3,6 @@
 #ifndef _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
 #define _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
 #include <sigc++/adaptors/adaptor_trait.h>
-#include <sigc++/adaptors/bound_argument.h>
 
 namespace sigc {
 
@@ -21,29 +20,29 @@ struct bind_return_functor : public adapts<T_functor>
 {
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
-    { typedef typename unwrap_reference<T_return>::type type; };
-  typedef typename unwrap_reference<T_return>::type result_type;
+    { typedef T_return type; };
+  typedef T_return result_type;
 
   /** Invokes the wrapped functor dropping its return value.
    * @return The fixed return value.
    */
-  typename unwrap_reference<T_return>::type operator()();
+  T_return operator()();
 
   /** Invokes the wrapped functor passing on the arguments.,
    * @param _A_arg%1 Argument to be passed on to the functor.)
    * @return The fixed return value.
    */
   template <class T_arg1>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1)
+  inline T_return operator()(T_arg1 _A_a1)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
-        (_A_a1); return ret_value_.invoke();
+        (_A_a1); return ret_value_;
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
-  inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1)
+  inline T_return sun_forte_workaround(T_arg1 _A_a1)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
-        (_A_a1); return ret_value_.invoke();
+        (_A_a1); return ret_value_;
     }
   #endif
 
@@ -52,16 +51,16 @@ struct bind_return_functor : public adapts<T_functor>
    * @return The fixed return value.
    */
   template <class T_arg1,class T_arg2>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
-        (_A_a1,_A_a2); return ret_value_.invoke();
+        (_A_a1,_A_a2); return ret_value_;
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
-  inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
-        (_A_a1,_A_a2); return ret_value_.invoke();
+        (_A_a1,_A_a2); return ret_value_;
     }
   #endif
 
@@ -70,16 +69,16 @@ struct bind_return_functor : public adapts<T_functor>
    * @return The fixed return value.
    */
   template <class T_arg1,class T_arg2,class T_arg3>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
-        (_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3); return ret_value_;
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
-  inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
-        (_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3); return ret_value_;
     }
   #endif
 
@@ -88,16 +87,16 @@ struct bind_return_functor : public adapts<T_functor>
    * @return The fixed return value.
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
     }
   #endif
 
@@ -106,16 +105,16 @@ struct bind_return_functor : public adapts<T_functor>
    * @return The fixed return value.
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
     }
   #endif
 
@@ -124,16 +123,16 @@ struct bind_return_functor : public adapts<T_functor>
    * @return The fixed return value.
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
     }
   #endif
 
@@ -142,16 +141,16 @@ struct bind_return_functor : public adapts<T_functor>
    * @return The fixed return value.
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+  inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+  inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
-        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
+        (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
     }
   #endif
 
@@ -165,15 +164,14 @@ struct bind_return_functor : public adapts<T_functor>
     {}
 
   /// The fixed return value.
-  bound_argument<T_return> ret_value_; // public, so that visit_each() can access it
+  T_return ret_value_; // public, so that visit_each() can access it
 };
 
 template <class T_return, class T_functor>
-typename unwrap_reference<T_return>::type bind_return_functor<T_return, T_functor>::operator()()
-  { this->functor_(); return ret_value_.invoke(); }
+T_return bind_return_functor<T_return, T_functor>::operator()()
+  { this->functor_(); return ret_value_; }
 
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bind_return_functor performs a functor on the
  * functor and on the object instance stored in the sigc::bind_return_functor object.
@@ -198,9 +196,9 @@ void visit_each(const T_action& _A_action,
  * @ingroup bind
  */
 template <class T_return, class T_functor>
-inline bind_return_functor<T_return, T_functor>
+inline bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>
 bind_return(const T_functor& _A_functor, T_return _A_ret_value)
-{ return bind_return_functor<T_return, T_functor>(_A_functor, _A_ret_value); }
+{ return bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>(_A_functor, _A_ret_value); }
 
 } /* namespace sigc */
 #endif /* _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_ */
diff --git a/libs/sigc++2/sigc++/adaptors/bound_argument.h b/libs/sigc++2/sigc++/adaptors/bound_argument.h
deleted file mode 100644
index f6c65afe76..0000000000
--- a/libs/sigc++2/sigc++/adaptors/bound_argument.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright 2005, The libsigc++ Development Team
- *
- * 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.1 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
- */
-
-#ifndef _SIGC_BOUND_ARGUMENT_H_
-#define _SIGC_BOUND_ARGUMENT_H_
-
-
-#include <sigc++/limit_reference.h>
-#include <sigc++/reference_wrapper.h>
-
-
-namespace sigc {
-
-/** A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return()) argument.
- *
- * If Foo is a wrapped reference to a class Bar (reference_wrapper<Bar>) then this
- * object is implemented on top of a limit_reference. When the slot is
- * invoked, the limit_reference::invoke() method provides the argument (a Bar&).
- * When the slot is visited (e.g. visit_each<>()), we simply visit the limit_reference,
- * which will visit the derived type, or a sigc::trackable base if necessary.
- *
- * Likewise, If Foo is a wrapped const reference to a class Bar (const_reference_wrapper<Bar>)
- * then this object is implemented on top of a const_limit_reference.
- * 
- * If Foo is something else (such as an argument that is bound by value) bound_argument just
- * stores a cop of that value, and both invoke() and visit() simply return it.
- * 
- * This object is used by the bind_functor<> and bind_return_functor<> objects,
- * depending on whether the argument is bound as a parameter or as a return value.
- *
- * The general template implementation is used for parameters that are passed by value.
- * @e T_type The type of the bound argument.
- */
-template <class T_type>
-class bound_argument
-{
-public:
-  /** Constructor.
-   * @param _A_argument The argument to bind.
-   */
-  bound_argument(const T_type& _A_argument)
-    : visited_(_A_argument)
-    {}
-
-  /** Retrieve the entity to visit in visit_each().
-   * @return The bound argument.
-   */
-  inline const T_type& visit() const
-    { return visited_; }
-
-  /** Retrieve the entity to pass to the bound functor or return.
-   * @return The bound argument.
-   */
-  inline T_type& invoke()
-    { return visited_; }
-
-private:
-  /** The value of the argument.
-   */
-  T_type visited_;
-};
-
-//Template specialization:
-/** bound_argument object for a bound argument that is passed by bind() or
- * returned by bind_return() by reference, specialized for reference_wrapper<> types.
- * @e T_wrapped The type of the bound argument.
- */
-template <class T_wrapped>
-class bound_argument< reference_wrapper<T_wrapped> >
-{
-public:
-  /** Constructor.
-   * @param _A_argument The argument to bind.
-   */
-  bound_argument(const reference_wrapper<T_wrapped>& _A_argument)
-    : visited_(unwrap(_A_argument))
-    {}
-
-  /** Retrieve the entity to visit in visit_each().
-   * @return The limited_reference to the bound argument.
-   */
-  inline const limit_reference<T_wrapped>& visit() const
-    { return visited_; }
-
-  /** Retrieve the entity to pass to the bound functor or return.
-   * @return The bound argument.
-   */
-  inline T_wrapped& invoke()
-    { return visited_.invoke(); }
-
-private:
-  /** The limited_reference to the bound argument.
-   */
-  limit_reference<T_wrapped> visited_;
-};
-
-/** bound_argument object for a bound argument that is passed by bind() or
- * returned by bind_return() by const reference, specialized for const reference_wrapper<> types.
- * - @e T_wrapped The type of the bound argument.
- */
-template <class T_wrapped>
-class bound_argument< const_reference_wrapper<T_wrapped> >
-{
-public:
-  /** Constructor.
-   * @param _A_argument The argument to bind.
-   */
-  bound_argument(const const_reference_wrapper<T_wrapped>& _A_argument)
-    : visited_(unwrap(_A_argument))
-    {}
-
-  /** Retrieve the entity to visit in visit_each().
-   * @return The const_limited_reference to the bound argument.
-   */
-  inline const const_limit_reference<T_wrapped>& visit() const
-    { return visited_; }
-
-  /** Retrieve the entity to pass to the bound functor or return.
-   * @return The bound argument.
-   */
-  inline const T_wrapped& invoke()
-    { return visited_.invoke(); }
-
-private:
-  /** The const_limited_reference to the bound argument.
-   */
-  const_limit_reference<T_wrapped> visited_;
-};
-
-/** Implementation of visit_each() specialized for the bound_argument class.
- * Call visit_each() on the entity returned by the bound_argument's visit()
- * method.
- * @e T_action The type of functor to invoke.
- * @e T_type The type of bound_argument.
- * @param _A_action The functor to invoke.
- * @param _A_argument The visited instance.
- */
-template <class T_action, class T_type>
-void
-visit_each(const T_action& _A_action,
-           const bound_argument<T_type>& _A_argument)
-{
-  visit_each(_A_action, _A_argument.visit());
-}
-
-
-} /* namespace sigc */
-
-
-#endif /* _SIGC_BOUND_ARGUMENT_H_ */
diff --git a/libs/sigc++2/sigc++/adaptors/compose.h b/libs/sigc++2/sigc++/adaptors/compose.h
index 2308c8de5e..0f098ff2df 100644
--- a/libs/sigc++2/sigc++/adaptors/compose.h
+++ b/libs/sigc++2/sigc++/adaptors/compose.h
@@ -51,10 +51,8 @@ template <class T_setter, class T_getter>
 struct compose1_functor : public adapts<T_setter>
 {
   typedef typename adapts<T_setter>::adaptor_type adaptor_type;
-  typedef T_setter setter_type;
-  typedef T_getter getter_type;
 
-  template <class T_arg1 = void,class T_arg2 = void,class T_arg3 = void,class T_arg4 = void,class T_arg5 = void,class T_arg6 = void,class T_arg7 = void>
+  template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
     { typedef typename adaptor_type::template deduce_result_type<
         typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
@@ -123,7 +121,7 @@ struct compose1_functor : public adapts<T_setter>
     : adapts<T_setter>(_A_setter), get_(_A_getter)
     {}
 
-  getter_type get_; // public, so that visit_each() can access it
+  T_getter get_; // public, so that visit_each() can access it
 };
 
 template <class T_setter, class T_getter>
@@ -145,10 +143,7 @@ template <class T_setter, class T_getter1, class T_getter2>
 struct compose2_functor : public adapts<T_setter>
 {
   typedef typename adapts<T_setter>::adaptor_type adaptor_type;
-  typedef T_setter setter_type;
-  typedef T_getter1 getter1_type;
-  typedef T_getter2 getter2_type;
-  
+
   template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
   struct deduce_result_type
     { typedef typename adaptor_type::template deduce_result_type<
@@ -228,8 +223,8 @@ struct compose2_functor : public adapts<T_setter>
     : adapts<T_setter>(_A_setter), get1_(_A_getter1), get2_(_A_getter2)
     {}
 
-  getter1_type get1_; // public, so that visit_each() can access it
-  getter2_type get2_; // public, so that visit_each() can access it
+  T_getter1 get1_; // public, so that visit_each() can access it
+  T_getter2 get2_; // public, so that visit_each() can access it
 };
 
 template <class T_setter, class T_getter1, class T_getter2>
@@ -237,7 +232,7 @@ typename compose2_functor<T_setter, T_getter1, T_getter2>::result_type
 compose2_functor<T_setter, T_getter1, T_getter2>::operator()()
   { return this->functor_(get1_(), get2_()); }
 
-//template specialization of visit_each<>(action, functor):
+
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::compose1_functor performs a functor on the
  * functors stored in the sigc::compose1_functor object.
@@ -248,17 +243,10 @@ template <class T_action, class T_setter, class T_getter>
 void visit_each(const T_action& _A_action,
                 const compose1_functor<T_setter, T_getter>& _A_target)
 {
-  typedef compose1_functor<T_setter, T_getter> type_functor;
-  
-  //Note that the AIX compiler needs the actual template types of visit_each to be specified:
-  typedef typename type_functor::setter_type type_functor1;
-  visit_each<T_action, type_functor1>(_A_action, _A_target.functor_);
-  
-  typedef typename type_functor::getter_type type_functor_getter;
-  visit_each<T_action, type_functor_getter>(_A_action, _A_target.get_);
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.get_);
 }
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::compose2_functor performs a functor on the
  * functors stored in the sigc::compose2_functor object.
@@ -269,17 +257,9 @@ template <class T_action, class T_setter, class T_getter1, class T_getter2>
 void visit_each(const T_action& _A_action,
                 const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
 {
-  typedef compose2_functor<T_setter, T_getter1, T_getter2> type_functor;
-  
-  //Note that the AIX compiler needs the actual template types of visit_each to be specified:
-  typedef typename type_functor::setter_type type_functor1;
-  visit_each<T_action, type_functor1>(_A_action, _A_target.functor_);
-  
-  typedef typename type_functor::getter1_type type_functor_getter1;
-  visit_each<T_action, type_functor_getter1>(_A_action, _A_target.get1_);
-  
-  typedef typename type_functor::getter2_type type_functor_getter2;
-  visit_each<T_action, type_functor_getter2>(_A_action, _A_target.get2_);
+  visit_each(_A_action, _A_target.functor_);
+  visit_each(_A_action, _A_target.get1_);
+  visit_each(_A_action, _A_target.get2_);
 }
 
 
diff --git a/libs/sigc++2/sigc++/adaptors/exception_catch.h b/libs/sigc++2/sigc++/adaptors/exception_catch.h
index 0303e07c37..cd7c41e67d 100644
--- a/libs/sigc++2/sigc++/adaptors/exception_catch.h
+++ b/libs/sigc++2/sigc++/adaptors/exception_catch.h
@@ -165,7 +165,8 @@ struct exception_catch_functor : public adapts<T_functor>
     : adapts<T_functor>(_A_func), catcher_(_A_catcher)
     {}
 
-  T_catcher catcher_; 
+  protected: 
+    T_catcher catcher_; 
 };
 
 template <class T_functor, class T_catcher, class T_return>
@@ -286,6 +287,7 @@ struct exception_catch_functor<T_functor, T_catcher, void> : public adapts<T_fun
     {}
   ~exception_catch_functor() {}
 
+  protected: 
     T_catcher catcher_; 
 };
 
@@ -298,8 +300,7 @@ void exception_catch_functor<T_functor, T_catcher, void>::operator()()
       { this->catcher_(); }
   }
 
-  
-//template specialization of visit_each<>(action, functor):
+
 template <class T_action, class T_functor, class T_catcher, class T_return>
 void visit_each(const T_action& _A_action,
                 const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
diff --git a/libs/sigc++2/sigc++/adaptors/hide.h b/libs/sigc++2/sigc++/adaptors/hide.h
index 7a9f096407..1b820fea6b 100644
--- a/libs/sigc++2/sigc++/adaptors/hide.h
+++ b/libs/sigc++2/sigc++/adaptors/hide.h
@@ -87,7 +87,7 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
-  operator()(T_arg1)
+  operator()(T_arg1 _A_a1)
     { return this->functor_(); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -104,14 +104,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
-  operator()(T_arg1 _A_a1, T_arg2)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
         (_A_a1); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
         (_A_a1); }
   #endif
@@ -124,14 +124,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  operator()(T_arg1 _A_a1,T_arg2 _A_a2, T_arg3)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
         (_A_a1, _A_a2); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2, T_arg3)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
         (_A_a1, _A_a2); }
   #endif
@@ -145,14 +145,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3, T_arg4)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
         (_A_a1, _A_a2, _A_a3); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3, T_arg4)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
         (_A_a1, _A_a2, _A_a3); }
   #endif
@@ -167,14 +167,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4, T_arg5)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4, T_arg5)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4); }
   #endif
@@ -190,14 +190,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5, T_arg6)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5, T_arg6)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
   #endif
@@ -214,14 +214,14 @@ struct hide_functor <-1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6, T_arg7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6, T_arg7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
   #endif
@@ -256,7 +256,7 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1>
   typename deduce_result_type<T_arg1>::type
-  operator()(T_arg1)
+  operator()(T_arg1 _A_a1)
     { return this->functor_(); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -273,14 +273,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
-  operator()(T_arg1, T_arg2 _A_a2)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
         (_A_a2); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
-  sun_forte_workaround(T_arg1, T_arg2 _A_a2)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
         (_A_a2); }
   #endif
@@ -293,14 +293,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
         (_A_a2, _A_a3); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
         (_A_a2, _A_a3); }
   #endif
@@ -314,14 +314,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a2, _A_a3, _A_a4); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a2, _A_a3, _A_a4); }
   #endif
@@ -336,14 +336,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a2, _A_a3, _A_a4, _A_a5); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a2, _A_a3, _A_a4, _A_a5); }
   #endif
@@ -359,14 +359,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
   #endif
@@ -383,14 +383,14 @@ struct hide_functor <0, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
   #endif
@@ -426,14 +426,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
-  operator()(T_arg1 _A_a1, T_arg2)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
         (_A_a1); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   typename deduce_result_type<T_arg1,T_arg2>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
         (_A_a1); }
   #endif
@@ -446,14 +446,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
         (_A_a1, _A_a3); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
         (_A_a1, _A_a3); }
   #endif
@@ -467,14 +467,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a3, _A_a4); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a3, _A_a4); }
   #endif
@@ -489,14 +489,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a3, _A_a4, _A_a5); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a3, _A_a4, _A_a5); }
   #endif
@@ -512,14 +512,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
   #endif
@@ -536,14 +536,14 @@ struct hide_functor <1, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
   #endif
@@ -580,14 +580,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
         (_A_a1, _A_a2); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
         (_A_a1, _A_a2); }
   #endif
@@ -601,14 +601,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a2, _A_a4); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a2, _A_a4); }
   #endif
@@ -623,14 +623,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a4, _A_a5); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a4, _A_a5); }
   #endif
@@ -646,14 +646,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
   #endif
@@ -670,14 +670,14 @@ struct hide_functor <2, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
   #endif
@@ -715,14 +715,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
         (_A_a1, _A_a2, _A_a3); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
         (_A_a1, _A_a2, _A_a3); }
   #endif
@@ -737,14 +737,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a5); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a5); }
   #endif
@@ -760,14 +760,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
   #endif
@@ -784,14 +784,14 @@ struct hide_functor <3, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
   #endif
@@ -830,14 +830,14 @@ struct hide_functor <4, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4); }
   #endif
@@ -853,14 +853,14 @@ struct hide_functor <4, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
   #endif
@@ -877,14 +877,14 @@ struct hide_functor <4, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
   #endif
@@ -924,14 +924,14 @@ struct hide_functor <5, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
   #endif
@@ -948,14 +948,14 @@ struct hide_functor <5, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg7>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
   #endif
@@ -996,14 +996,14 @@ struct hide_functor <6, T_functor> : public adapts<T_functor>
    */
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
+  operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
-  sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
+  sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
         (_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
   #endif
@@ -1018,7 +1018,6 @@ struct hide_functor <6, T_functor> : public adapts<T_functor>
 };
 
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::hide_functor performs a functor on the
  * functor stored in the sigc::hide_functor object.
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/base.h b/libs/sigc++2/sigc++/adaptors/lambda/base.h
index a45594c2f6..6a2c402c89 100644
--- a/libs/sigc++2/sigc++/adaptors/lambda/base.h
+++ b/libs/sigc++2/sigc++/adaptors/lambda/base.h
@@ -3,7 +3,6 @@
 #ifndef _SIGC_LAMBDA_BASE_HPP_
 #define _SIGC_LAMBDA_BASE_HPP_
 #include <sigc++/adaptors/adaptor_trait.h>
-#include <sigc++/reference_wrapper.h>
 
 namespace sigc {
 
@@ -202,72 +201,72 @@ struct lambda_core<T_type, false> : public lambda_base
   result_type operator()() const;
 
   template <class T_arg1>
-  result_type operator ()(T_arg1) const 
+  result_type operator ()(T_arg1 _A_1) const 
     { return value_; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
-  result_type sun_forte_workaround(T_arg1) const
+  result_type sun_forte_workaround(T_arg1 _A_1) const
     { return value_; }
   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
   template <class T_arg1,class T_arg2>
-  result_type operator ()(T_arg1,T_arg2) const 
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2) const 
     { return value_; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
-  result_type sun_forte_workaround(T_arg1,T_arg2) const
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
     { return value_; }
   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
   template <class T_arg1,class T_arg2,class T_arg3>
-  result_type operator ()(T_arg1,T_arg2,T_arg3) const 
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const 
     { return value_; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
-  result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3) const
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
     { return value_; }
   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4) const 
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const 
     { return value_; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4) const
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
     { return value_; }
   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const 
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const 
     { return value_; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
     { return value_; }
   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const 
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const 
     { return value_; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
     { return value_; }
   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const 
+  result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const 
     { return value_; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const
+  result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
     { return value_; }
   #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
@@ -284,7 +283,6 @@ typename lambda_core<T_type, false>::result_type lambda_core<T_type, false>::ope
 } /* namespace internal */
 
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_functor, bool I_islambda>
 void visit_each(const T_action& _A_action,
                 const internal::lambda_core<T_functor, I_islambda>& _A_target)
@@ -342,7 +340,6 @@ struct lambda : public internal::lambda_core<T_type>
 };
 
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_type>
 void visit_each(const T_action& _A_action,
                 const lambda<T_type>& _A_target)
@@ -351,32 +348,12 @@ void visit_each(const T_action& _A_action,
 }
 
 
-/** Converts a reference into a lambda object.
- * sigc::var creates a 0-ary functor, returning the value of a referenced variable. 
- *
- * @par Example:
- *   @code
- *   int main(int argc, char* argv)
- *   {
- *     int data;
- *     sigc::signal<int> readValue;
- *
- *     readValue.connect(sigc::var(data));
- *
- *     data = 3;
- *     std::cout << readValue() << std::endl; //Prints 3.
- *
- *    data = 5;
- *    std::cout << readValue() << std::endl; //Prints 5.
- *   }
- *   @endcode
- */
+/// Converts a reference into a lambda object.
 template <class T_type>
 lambda<T_type&> var(T_type& v)
 { return lambda<T_type&>(v); }
 
-/** Converts a constant reference into a lambda object.
- */
+/// Converts a constant reference into a lambda object.
 template <class T_type>
 lambda<const T_type&> var(const T_type& v)
 { return lambda<const T_type&>(v); }
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/group.h b/libs/sigc++2/sigc++/adaptors/lambda/group.h
index ef778df81d..7b7525dc41 100644
--- a/libs/sigc++2/sigc++/adaptors/lambda/group.h
+++ b/libs/sigc++2/sigc++/adaptors/lambda/group.h
@@ -223,7 +223,6 @@ lambda_group1<T_functor, T_type1>::operator ()() const
   { return func_(value1_()); }
 
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_functor, class T_type1>
 void visit_each(const T_action& _A_action,
                 const lambda_group1<T_functor, T_type1>& _A_target)
@@ -435,7 +434,6 @@ lambda_group2<T_functor, T_type1,T_type2>::operator ()() const
   { return func_(value1_(),value2_()); }
 
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_functor, class T_type1,class T_type2>
 void visit_each(const T_action& _A_action,
                 const lambda_group2<T_functor, T_type1,T_type2>& _A_target)
@@ -694,7 +692,6 @@ lambda_group3<T_functor, T_type1,T_type2,T_type3>::operator ()() const
   { return func_(value1_(),value2_(),value3_()); }
 
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3>
 void visit_each(const T_action& _A_action,
                 const lambda_group3<T_functor, T_type1,T_type2,T_type3>& _A_target)
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/operator.h b/libs/sigc++2/sigc++/adaptors/lambda/operator.h
index ca74e6271f..5d9e00bcde 100644
--- a/libs/sigc++2/sigc++/adaptors/lambda/operator.h
+++ b/libs/sigc++2/sigc++/adaptors/lambda/operator.h
@@ -750,7 +750,6 @@ lambda_operator<T_action, T_type1, T_type2>::operator ()() const
       typename arg2_type::result_type>
       (arg1_(), arg2_()); }
 
-//template specialization of visit_each<>(action, functor):      
 template <class T_action, class T_lambda_action, class T_arg1, class T_arg2>
 void visit_each(const T_action& _A_action,
                 const lambda_operator<T_lambda_action, T_arg1, T_arg2>& _A_target)
@@ -945,7 +944,6 @@ lambda_operator_unary<T_action, T_type>::operator ()() const
       typename arg_type::result_type>
       (arg_()); }
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_lambda_action, class T_arg>
 void visit_each(const T_action& _A_action,
                 const lambda_operator_unary<T_lambda_action, T_arg>& _A_target)
@@ -1139,7 +1137,6 @@ lambda_operator_convert<T_action, T_type, T_arg>::operator ()() const
       typename arg_type::result_type>
       (arg_()); }
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_lambda_action, class T_type, class T_arg>
 void visit_each(const T_action& _A_action,
                 const lambda_operator_convert<T_lambda_action, T_type, T_arg>& _A_target)
diff --git a/libs/sigc++2/sigc++/adaptors/lambda/select.h b/libs/sigc++2/sigc++/adaptors/lambda/select.h
index 2fbe97b626..7cbf3eccfb 100644
--- a/libs/sigc++2/sigc++/adaptors/lambda/select.h
+++ b/libs/sigc++2/sigc++/adaptors/lambda/select.h
@@ -25,57 +25,57 @@ struct lambda_select1 : public lambda_base
   #endif
   
   template <class T_arg1,class T_arg2>
-  T_arg1 operator ()(T_arg1 _A_1, T_arg2) const { return _A_1; }
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
-  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2) const { return _A_1; }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3>
-  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
-  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
-  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
-  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
-  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
+  T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_1; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   //Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
-  T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
+  T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_1; }
   #endif
   
 };
@@ -89,57 +89,57 @@ struct lambda_select2 : public lambda_base
 
   void operator ()() const; // not implemented
   template <class T_arg1,class T_arg2>
-  T_arg2 operator ()(T_arg1, T_arg2 _A_2) const { return _A_2; }
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2) const { return _A_2; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
-  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2) const { return _A_2; }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_2; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3>
-  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
-  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
-  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
-  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_2; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
-  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_2; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
+  T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_2; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   //Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
-  T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
+  T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_2; }
   #endif
   
 };
@@ -153,48 +153,48 @@ struct lambda_select3 : public lambda_base
 
   void operator ()() const; // not implemented
   template <class T_arg1,class T_arg2,class T_arg3>
-  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_3; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
-  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_3; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
-  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
-  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_3; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
-  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_3; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
+  T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_3; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   //Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
-  T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
+  T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_3; }
   #endif
   
 };
@@ -208,39 +208,39 @@ struct lambda_select4 : public lambda_base
 
   void operator ()() const; // not implemented
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_4; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
-  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_4; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
-  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_4; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
-  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_4; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
+  T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_4; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   //Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
-  T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
+  T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_4; }
   #endif
   
 };
@@ -254,30 +254,30 @@ struct lambda_select5 : public lambda_base
 
   void operator ()() const; // not implemented
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-  T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
+  T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_5; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
-  T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
+  T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_5; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
+  T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_5; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
-  T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
+  T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_5; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
+  T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_5; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   //Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
-  T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
+  T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_5; }
   #endif
   
 };
@@ -291,21 +291,21 @@ struct lambda_select6 : public lambda_base
 
   void operator ()() const; // not implemented
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-  T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
+  T_arg6 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_6; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
-  T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
+  T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_6; }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
+  T_arg6 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_6; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   //Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
-  T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
+  T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_6; }
   #endif
   
 };
@@ -319,12 +319,12 @@ struct lambda_select7 : public lambda_base
 
   void operator ()() const; // not implemented
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
-  T_arg7 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
+  T_arg7 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_7; }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   //Does not work: T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
-  T_arg7 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
+  T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_7; }
   #endif
   
 };
diff --git a/libs/sigc++2/sigc++/adaptors/retype.h b/libs/sigc++2/sigc++/adaptors/retype.h
index f3d95a191f..01f71fcaa7 100644
--- a/libs/sigc++2/sigc++/adaptors/retype.h
+++ b/libs/sigc++2/sigc++/adaptors/retype.h
@@ -81,7 +81,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1>::type
   operator()(T_arg1 _A_a1)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
-        (static_cast<T_type1>(_A_a1));
+        ((T_type1)_A_a1);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -89,7 +89,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1>::type
   sun_forte_workaround(T_arg1 _A_a1)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
-        (static_cast<T_type1>(_A_a1));
+        ((T_type1)_A_a1);
     }
   #endif
 
@@ -97,7 +97,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2>::type
   operator()(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2));
+        ((T_type1)_A_a1,(T_type2)_A_a2);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -105,7 +105,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2>::type
   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2));
+        ((T_type1)_A_a1,(T_type2)_A_a2);
     }
   #endif
 
@@ -113,7 +113,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -121,7 +121,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
     }
   #endif
 
@@ -129,7 +129,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -137,7 +137,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
     }
   #endif
 
@@ -145,7 +145,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -153,7 +153,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
     }
   #endif
 
@@ -161,7 +161,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -169,7 +169,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
     }
   #endif
 
@@ -177,7 +177,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
   operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
@@ -185,7 +185,7 @@ struct retype_functor
   typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
   sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
     }
   #endif
 
@@ -203,8 +203,7 @@ typename retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_typ
 retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
   { return this->functor_(); }
 
-  
-//template specialization of visit_each<>(action, functor):
+
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::retype_functor performs a functor on the
  * functor stored in the sigc::retype_functor object.
diff --git a/libs/sigc++2/sigc++/adaptors/retype_return.h b/libs/sigc++2/sigc++/adaptors/retype_return.h
index 16d557ca72..ea413a0b30 100644
--- a/libs/sigc++2/sigc++/adaptors/retype_return.h
+++ b/libs/sigc++2/sigc++/adaptors/retype_return.h
@@ -264,8 +264,7 @@ template <class T_functor>
 void retype_return_functor<void, T_functor>::operator()()
   { this->functor_(); }
 
-  
-//template specialization of visit_each<>(action, functor):
+
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::retype_return_functor performs a functor on the
  * functor stored in the sigc::retype_return_functor object.
diff --git a/libs/sigc++2/sigc++/connection.cc b/libs/sigc++2/sigc++/connection.cc
index ff785e5e63..8f4363482f 100644
--- a/libs/sigc++2/sigc++/connection.cc
+++ b/libs/sigc++2/sigc++/connection.cc
@@ -103,7 +103,7 @@ void connection::set_slot(slot_base* sl)
 
 void* connection::notify(void* data)
 {
-  connection* self = reinterpret_cast<connection*>(data);
+  connection* self = (connection*)data;
   self->slot_ = 0;
   return 0;
 }
diff --git a/libs/sigc++2/sigc++/functors/mem_fun.h b/libs/sigc++2/sigc++/functors/mem_fun.h
index e652b7cf4b..2bd7cde67f 100644
--- a/libs/sigc++2/sigc++/functors/mem_fun.h
+++ b/libs/sigc++2/sigc++/functors/mem_fun.h
@@ -10,7 +10,6 @@
 #define _SIGC_FUNCTORS_MACROS_MEM_FUNHM4_
 #include <sigc++/type_traits.h>
 #include <sigc++/functors/functor_trait.h>
-#include <sigc++/limit_reference.h>
 
 namespace sigc {
 
@@ -1744,7 +1743,6 @@ protected:
   function_type func_ptr_;
 };
 
-
 /** bound_mem_functor0 encapsulates a  method with 0 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor0.
  *
@@ -1767,32 +1765,26 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor0( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor0 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor0( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @return The return value of the method invocation.
    */
   T_return operator()() const
-    { return (obj_.invoke().*(this->func_ptr_))(); }
+    { return (obj_ptr_->*(this->func_ptr_))(); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -1803,10 +1795,9 @@ template <class T_action, class T_return, class T_obj>
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor0<T_return, T_obj>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_mem_functor1 encapsulates a  method with 1 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor1.
  *
@@ -1830,33 +1821,27 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor1( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor1 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor1( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -1867,10 +1852,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1>
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_mem_functor2 encapsulates a  method with 2 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor2.
  *
@@ -1895,18 +1879,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor2( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor2 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor2( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -1914,15 +1894,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -1933,10 +1911,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_mem_functor3 encapsulates a  method with 3 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor3.
  *
@@ -1962,18 +1939,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor3( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor3 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor3( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -1982,15 +1955,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -2001,10 +1972,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_mem_functor4 encapsulates a  method with 4 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor4.
  *
@@ -2031,18 +2001,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor4( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor4 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor4( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2052,15 +2018,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -2071,10 +2035,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_mem_functor5 encapsulates a  method with 5 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor5.
  *
@@ -2102,18 +2065,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor5( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor5 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor5( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2124,15 +2083,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -2143,10 +2100,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_mem_functor6 encapsulates a  method with 6 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor6.
  *
@@ -2175,18 +2131,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor6( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor6 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor6( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2198,15 +2150,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -2217,10 +2167,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_mem_functor7 encapsulates a  method with 7 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_mem_functor7.
  *
@@ -2250,18 +2199,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor7( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_mem_functor7 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_mem_functor7( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2274,15 +2219,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_mem_functor object.
@@ -2293,10 +2236,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor0.
  *
@@ -2319,32 +2261,26 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor0(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor0 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor0(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @return The return value of the method invocation.
    */
   T_return operator()() const
-    { return (obj_.invoke().*(this->func_ptr_))(); }
+    { return (obj_ptr_->*(this->func_ptr_))(); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2355,10 +2291,9 @@ template <class T_action, class T_return, class T_obj>
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor0<T_return, T_obj>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor1.
  *
@@ -2382,33 +2317,27 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor1(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor1 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor1(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2419,10 +2348,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1>
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor2.
  *
@@ -2447,18 +2375,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor2(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor2 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor2(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2466,15 +2390,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2485,10 +2407,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor3.
  *
@@ -2514,18 +2435,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor3(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor3 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor3(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2534,15 +2451,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2553,10 +2468,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor4.
  *
@@ -2583,18 +2497,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor4(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor4 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor4(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2604,15 +2514,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2623,10 +2531,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor5.
  *
@@ -2654,18 +2561,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor5(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor5 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor5(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2676,15 +2579,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2695,10 +2596,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor6.
  *
@@ -2727,18 +2627,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor6(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor6 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor6(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2750,15 +2646,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2769,10 +2663,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_mem_functor7.
  *
@@ -2802,18 +2695,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor7(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_mem_functor7 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_mem_functor7(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -2826,15 +2715,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_mem_functor object.
@@ -2845,10 +2732,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor0.
  *
@@ -2871,32 +2757,26 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor0( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor0 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor0( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @return The return value of the method invocation.
    */
   T_return operator()() const
-    { return (obj_.invoke().*(this->func_ptr_))(); }
+    { return (obj_ptr_->*(this->func_ptr_))(); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -2907,10 +2787,9 @@ template <class T_action, class T_return, class T_obj>
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor0<T_return, T_obj>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor1.
  *
@@ -2934,33 +2813,27 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor1( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor1 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor1( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -2971,10 +2844,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1>
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor2.
  *
@@ -2999,18 +2871,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor2( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor2 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor2( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3018,15 +2886,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -3037,10 +2903,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor3.
  *
@@ -3066,18 +2931,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor3( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor3 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor3( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3086,15 +2947,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -3105,10 +2964,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor4.
  *
@@ -3135,18 +2993,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor4( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor4 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor4( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3156,15 +3010,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -3175,10 +3027,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor5.
  *
@@ -3206,18 +3057,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor5( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor5 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor5( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3228,15 +3075,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -3247,10 +3092,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor6.
  *
@@ -3279,18 +3123,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor6( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor6 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor6( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3302,15 +3142,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -3321,10 +3159,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor7.
  *
@@ -3354,18 +3191,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor7( T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_volatile_mem_functor7 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_volatile_mem_functor7( T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3378,15 +3211,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+   T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_volatile_mem_functor object.
@@ -3397,10 +3228,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor0.
  *
@@ -3423,32 +3253,26 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor0(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor0 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor0(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @return The return value of the method invocation.
    */
   T_return operator()() const
-    { return (obj_.invoke().*(this->func_ptr_))(); }
+    { return (obj_ptr_->*(this->func_ptr_))(); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3459,10 +3283,9 @@ template <class T_action, class T_return, class T_obj>
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor1.
  *
@@ -3486,33 +3309,27 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor1(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor1 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor1(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3523,10 +3340,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1>
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor2.
  *
@@ -3551,18 +3367,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor2(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor2 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor2(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3570,15 +3382,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3589,10 +3399,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor3.
  *
@@ -3618,18 +3427,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor3(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor3 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor3(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3638,15 +3443,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3657,10 +3460,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor4.
  *
@@ -3687,18 +3489,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor4(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor4 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor4(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3708,15 +3506,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3727,10 +3523,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor5.
  *
@@ -3758,18 +3553,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor5(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor5 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor5(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3780,15 +3571,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3799,10 +3588,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor6.
  *
@@ -3831,18 +3619,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor6(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor6 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor6(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3854,15 +3638,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3873,10 +3655,9 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
-
 /** bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance.
  * Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor7.
  *
@@ -3906,18 +3687,14 @@ public:
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor7(const T_obj* _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(*_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(_A_obj) {}
 
   /** Constructs a bound_const_volatile_mem_functor7 object that wraps the passed method.
    * @param _A_obj Reference to instance the method will operate on.
    * @param _A_func Pointer to method will be invoked from operator()().
    */
   bound_const_volatile_mem_functor7(const T_obj& _A_obj, function_type _A_func)
-    : base_type_(_A_func),
-      obj_(_A_obj)
-    {}
+    : base_type_(_A_func), obj_ptr_(&_A_obj) {}
 
   /** Execute the wrapped method operating on the stored instance.
    * @param _A_a1 Argument to be passed on to the method.
@@ -3930,15 +3707,13 @@ public:
    * @return The return value of the method invocation.
    */
   T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
-    { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+    { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
 
 //protected:
-  // Reference to stored object instance.
-  // This is the handler object, such as TheObject in void TheObject::signal_handler().
-  const_volatile_limit_reference<T_obj> obj_;
+  /// Pointer to stored object instance.
+  const T_obj *obj_ptr_;
 };
 
-//template specialization of visit_each<>(action, functor):
 /** Performs a functor on each of the targets of a functor.
  * The function overload for sigc::bound_const_volatile_mem_functor performs a functor
  * on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
@@ -3949,7 +3724,7 @@ template <class T_action, class T_return, class T_obj, class T_arg1,class T_arg2
 void visit_each(const T_action& _A_action,
                 const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
 {
-  sigc::visit_each(_A_action, _A_target.obj_);
+  visit_each(_A_action, *_A_target.obj_ptr_);
 }
 
 
diff --git a/libs/sigc++2/sigc++/functors/slot.h b/libs/sigc++2/sigc++/functors/slot.h
index 64ce6d77de..48c192a3c3 100644
--- a/libs/sigc++2/sigc++/functors/slot.h
+++ b/libs/sigc++2/sigc++/functors/slot.h
@@ -54,7 +54,7 @@ struct typed_slot_rep : public slot_rep
    */
   static void* destroy(void* data)
     {
-      self* self_ = static_cast<self*>(reinterpret_cast<slot_rep*>(data));
+      self* self_ = static_cast<self*>((slot_rep*)data);
       self_->call_ = 0;
       self_->destroy_ = 0;
       visit_each_type<trackable*>(slot_do_unbind(self_), self_->functor_);
@@ -73,8 +73,8 @@ struct typed_slot_rep : public slot_rep
    */
   static void* dup(void* data)
     {
-      slot_rep* a_rep = reinterpret_cast<slot_rep*>(data);
-      return static_cast<slot_rep*>(new self(*static_cast<self*>(a_rep)));
+      slot_rep* rep_ = (slot_rep*)data;
+      return static_cast<slot_rep*>(new self(*static_cast<self*>(rep_)));
     }
 };
 
@@ -437,7 +437,7 @@ public:
   inline T_return operator()() const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_);
       return T_return();
     }
 
@@ -449,10 +449,7 @@ public:
   template <class T_functor>
   slot0(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call0<T_functor, T_return>::address();
-    }
+    { rep_->call_ = internal::slot_call0<T_functor, T_return>::address(); }
 
   slot0(const slot0& src)
     : slot_base(src) {}
@@ -512,7 +509,7 @@ public:
   inline T_return operator()(arg1_type_ _A_a1) const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1);
       return T_return();
     }
 
@@ -524,10 +521,7 @@ public:
   template <class T_functor>
   slot1(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call1<T_functor, T_return, T_arg1>::address();
-    }
+    { rep_->call_ = internal::slot_call1<T_functor, T_return, T_arg1>::address(); }
 
   slot1(const slot1& src)
     : slot_base(src) {}
@@ -590,7 +584,7 @@ public:
   inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2) const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2);
       return T_return();
     }
 
@@ -602,10 +596,7 @@ public:
   template <class T_functor>
   slot2(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call2<T_functor, T_return, T_arg1,T_arg2>::address();
-    }
+    { rep_->call_ = internal::slot_call2<T_functor, T_return, T_arg1,T_arg2>::address(); }
 
   slot2(const slot2& src)
     : slot_base(src) {}
@@ -671,7 +662,7 @@ public:
   inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3) const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3);
       return T_return();
     }
 
@@ -683,10 +674,7 @@ public:
   template <class T_functor>
   slot3(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call3<T_functor, T_return, T_arg1,T_arg2,T_arg3>::address();
-    }
+    { rep_->call_ = internal::slot_call3<T_functor, T_return, T_arg1,T_arg2,T_arg3>::address(); }
 
   slot3(const slot3& src)
     : slot_base(src) {}
@@ -755,7 +743,7 @@ public:
   inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4) const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4);
       return T_return();
     }
 
@@ -767,10 +755,7 @@ public:
   template <class T_functor>
   slot4(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call4<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4>::address();
-    }
+    { rep_->call_ = internal::slot_call4<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4>::address(); }
 
   slot4(const slot4& src)
     : slot_base(src) {}
@@ -842,7 +827,7 @@ public:
   inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5) const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
       return T_return();
     }
 
@@ -854,10 +839,7 @@ public:
   template <class T_functor>
   slot5(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call5<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::address();
-    }
+    { rep_->call_ = internal::slot_call5<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::address(); }
 
   slot5(const slot5& src)
     : slot_base(src) {}
@@ -932,7 +914,7 @@ public:
   inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5,arg6_type_ _A_a6) const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
       return T_return();
     }
 
@@ -944,10 +926,7 @@ public:
   template <class T_functor>
   slot6(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call6<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::address();
-    }
+    { rep_->call_ = internal::slot_call6<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::address(); }
 
   slot6(const slot6& src)
     : slot_base(src) {}
@@ -1025,7 +1004,7 @@ public:
   inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5,arg6_type_ _A_a6,arg7_type_ _A_a7) const
     {
       if (!empty() && !blocked())
-        return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+        return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
       return T_return();
     }
 
@@ -1037,10 +1016,7 @@ public:
   template <class T_functor>
   slot7(const T_functor& _A_func)
     : slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
-    {
-      //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
-      slot_base::rep_->call_ = internal::slot_call7<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::address();
-    }
+    { rep_->call_ = internal::slot_call7<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::address(); }
 
   slot7(const slot7& src)
     : slot_base(src) {}
@@ -1102,19 +1078,17 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
 
-
 /** Convenience wrapper for the numbered sigc::slot0 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::slot
- * template for 0 argument(s), specialized for different numbers of arguments
- * This is possible because the template has default (nil_) template types.
+ * template for 0 argument(s).
  */
 template <class T_return>
-class slot <T_return, nil_, nil_, nil_, nil_, nil_, nil_, nil_>
+class slot <T_return>
   : public slot0<T_return>
 {
 public:
@@ -1130,18 +1104,16 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::slot1 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::slot
- * template for 1 argument(s), specialized for different numbers of arguments
- * This is possible because the template has default (nil_) template types.
+ * template for 1 argument(s).
  */
 template <class T_return, class T_arg1>
-class slot <T_return, T_arg1, nil_, nil_, nil_, nil_, nil_, nil_>
+class slot <T_return, T_arg1>
   : public slot1<T_return, T_arg1>
 {
 public:
@@ -1157,18 +1129,16 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::slot2 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::slot
- * template for 2 argument(s), specialized for different numbers of arguments
- * This is possible because the template has default (nil_) template types.
+ * template for 2 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2>
-class slot <T_return, T_arg1, T_arg2, nil_, nil_, nil_, nil_, nil_>
+class slot <T_return, T_arg1,T_arg2>
   : public slot2<T_return, T_arg1,T_arg2>
 {
 public:
@@ -1184,18 +1154,16 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::slot3 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::slot
- * template for 3 argument(s), specialized for different numbers of arguments
- * This is possible because the template has default (nil_) template types.
+ * template for 3 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
-class slot <T_return, T_arg1, T_arg2, T_arg3, nil_, nil_, nil_, nil_>
+class slot <T_return, T_arg1,T_arg2,T_arg3>
   : public slot3<T_return, T_arg1,T_arg2,T_arg3>
 {
 public:
@@ -1211,18 +1179,16 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::slot4 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::slot
- * template for 4 argument(s), specialized for different numbers of arguments
- * This is possible because the template has default (nil_) template types.
+ * template for 4 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil_, nil_, nil_>
+class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4>
   : public slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
 {
 public:
@@ -1238,18 +1204,16 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::slot5 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::slot
- * template for 5 argument(s), specialized for different numbers of arguments
- * This is possible because the template has default (nil_) template types.
+ * template for 5 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil_, nil_>
+class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
   : public slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
 {
 public:
@@ -1265,18 +1229,16 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::slot6 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::slot
- * template for 6 argument(s), specialized for different numbers of arguments
- * This is possible because the template has default (nil_) template types.
+ * template for 6 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil_>
+class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
   : public slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
 {
 public:
@@ -1292,7 +1254,7 @@ public:
     : parent_type(_A_func) {}
 
   slot(const slot& src)
-    : parent_type(reinterpret_cast<const parent_type&>(src)) {}
+    : parent_type((const parent_type&)src) {}
 };
 
 
diff --git a/libs/sigc++2/sigc++/functors/slot_base.cc b/libs/sigc++2/sigc++/functors/slot_base.cc
index 896276bd1b..bc0f173f22 100644
--- a/libs/sigc++2/sigc++/functors/slot_base.cc
+++ b/libs/sigc++2/sigc++/functors/slot_base.cc
@@ -49,19 +49,15 @@ void slot_rep::disconnect()
     parent_ = 0;        // Just a precaution.
     (cleanup_)(data_);  // Notify the parent (might lead to destruction of this!).
   }
-  else
-    call_ = 0;
 }
 
 //static
 void* slot_rep::notify(void* data)
 {
-  slot_rep* self_ = reinterpret_cast<slot_rep*>(data);
-
+  slot_rep* self_ = (slot_rep*)data;
   self_->call_ = 0; // Invalidate the slot.
   self_->destroy(); // Detach the stored functor from the other referred trackables and destroy it.
   self_->disconnect(); // Disconnect the slot (might lead to deletion of self_!).
-
   return 0;
 }
 
@@ -82,17 +78,7 @@ slot_base::slot_base(const slot_base& src)
   blocked_(src.blocked_)
 {
   if (src.rep_)
-  {
-    //Check call_ so we can ignore invalidated slots.
-    //Otherwise, destroyed bound reference parameters (whose destruction caused the slot's invalidation) may be used during dup().
-    //Note: I'd prefer to check somewhere during dup(). murrayc.
-    if (src.rep_->call_)
-      rep_ = src.rep_->dup();
-    else
-    {
-      *this = slot_base(); //Return the default invalid slot.
-    }
-  }
+    rep_ = src.rep_->dup();
 }
 
 slot_base::~slot_base()
diff --git a/libs/sigc++2/sigc++/functors/slot_base.h b/libs/sigc++2/sigc++/functors/slot_base.h
index a91c75db89..bb2ed343f3 100644
--- a/libs/sigc++2/sigc++/functors/slot_base.h
+++ b/libs/sigc++2/sigc++/functors/slot_base.h
@@ -101,7 +101,7 @@ struct SIGC_API slot_rep : public trackable
    * @return A deep copy of the slot_rep object.
    */
   inline slot_rep* dup() const
-    { return reinterpret_cast<slot_rep*>((*dup_)(const_cast<slot_rep*>(this))); }
+    { return (slot_rep*)(*dup_)(const_cast<slot_rep*>(this)); }
 
   /** Set the parent with a callback.
    * slots have one parent exclusively.
@@ -298,9 +298,7 @@ public:
    */
   void disconnect();
 
-//The Tru64 and Solaris Forte 5.5 compilers needs this operator=() to be public. I'm not sure why, or why it needs to be protected usually. murrayc.
-//See bug #168265. 
-//protected:
+protected:
   /** Overrides this slot making a copy from another slot.
    * @param src The slot from which to make a copy.
    * @return @p this.
diff --git a/libs/sigc++2/sigc++/limit_reference.h b/libs/sigc++2/sigc++/limit_reference.h
deleted file mode 100644
index 0425429235..0000000000
--- a/libs/sigc++2/sigc++/limit_reference.h
+++ /dev/null
@@ -1,455 +0,0 @@
-// -*- c++ -*-
-/* Do not edit! -- generated file */
-
-
-#ifndef _SIGC_MACROS_LIMIT_REFERENCEHM4_
-#define _SIGC_MACROS_LIMIT_REFERENCEHM4_
-
-
-#include <sigc++/type_traits.h>
-#include <sigc++/trackable.h>
-
-
-namespace sigc {
-
-
-/** A limit_reference<Foo> object stores a reference (Foo&), but make sure that,
- * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
- * sigc::trackable reference instead of the derived reference. This avoids use of
- * a reference to the derived type when the derived destructor has run. That can be
- * a problem when using virtual inheritance.
- *
- * If Foo inherits from trackable then both the derived reference and the
- * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
- * reference without doing an implicit conversion. To retrieve the derived reference
- * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
- * reference (so that you can call visit_each() on it), you use visit().
- *
- * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
- * derived reference.
- *
- * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values, 
- * and, with mem_fun(), the reference to the handling object.
- *
- * - @e T_type The type of the reference.
- */
-template <class T_type,
-          bool I_derives_trackable =
-            is_base_and_derived<trackable, T_type>::value>
-class limit_reference
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  limit_reference(T_type& _A_target)
-    : visited(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const T_type& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline T_type& invoke() const
-    { return visited; }
-
-private:
-  /** The reference.
-   */
-  T_type& visited;
-};
-
-/** limit_reference object for a class that derives from trackable.
- * - @e T_type The type of the reference.
- */
-template <class T_type>
-class limit_reference<T_type, true>
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  limit_reference(T_type& _A_target)
-    : visited(_A_target),
-      invoked(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const trackable& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline T_type& invoke() const
-    { return invoked; }
-
-private:
-  /** The trackable reference.
-   */
-  trackable& visited;
-
-  /** The reference.
-   */
-  T_type& invoked;
-};
-
-/** Implementation of visit_each() specialized for the limit_reference
- * class, to call visit_each() on the entity returned by the limit_reference's
- * visit() method.
- * - @e T_action The type of functor to invoke.
- * - @e T_type The type of the reference.
- * @param _A_action The functor to invoke.
- * @param _A_argument The visited instance.
- */
-template <class T_action, class T_type, bool I_derives_trackable>
-void
-visit_each(const T_action& _A_action,
-           const limit_reference<T_type, I_derives_trackable>& _A_target)
-{
-  visit_each(_A_action, _A_target.visit());
-}
-
-
-/** A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
- * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
- * sigc::trackable reference instead of the derived reference. This avoids use of
- * a reference to the derived type when the derived destructor has run. That can be
- * a problem when using virtual inheritance.
- *
- * If Foo inherits from trackable then both the derived reference and the
- * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
- * reference without doing an implicit conversion. To retrieve the derived reference
- * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
- * reference (so that you can call visit_each() on it), you use visit().
- *
- * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
- * derived reference.
- *
- * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values, 
- * and, with mem_fun(), the reference to the handling object.
- *
- * - @e T_type The type of the reference.
- */
-template <class T_type,
-          bool I_derives_trackable =
-            is_base_and_derived<trackable, T_type>::value>
-class const_limit_reference
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  const_limit_reference(const T_type& _A_target)
-    : visited(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const T_type& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline const T_type& invoke() const
-    { return visited; }
-
-private:
-  /** The reference.
-   */
-  const T_type& visited;
-};
-
-/** const_limit_reference object for a class that derives from trackable.
- * - @e T_type The type of the reference.
- */
-template <class T_type>
-class const_limit_reference<T_type, true>
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  const_limit_reference(const T_type& _A_target)
-    : visited(_A_target),
-      invoked(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const trackable& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline const T_type& invoke() const
-    { return invoked; }
-
-private:
-  /** The trackable reference.
-   */
-  const trackable& visited;
-
-  /** The reference.
-   */
-  const T_type& invoked;
-};
-
-/** Implementation of visit_each() specialized for the const_limit_reference
- * class, to call visit_each() on the entity returned by the const_limit_reference's
- * visit() method.
- * - @e T_action The type of functor to invoke.
- * - @e T_type The type of the reference.
- * @param _A_action The functor to invoke.
- * @param _A_argument The visited instance.
- */
-template <class T_action, class T_type, bool I_derives_trackable>
-void
-visit_each(const T_action& _A_action,
-           const const_limit_reference<T_type, I_derives_trackable>& _A_target)
-{
-  visit_each(_A_action, _A_target.visit());
-}
-
-
-/** A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
- * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
- * sigc::trackable reference instead of the derived reference. This avoids use of
- * a reference to the derived type when the derived destructor has run. That can be
- * a problem when using virtual inheritance.
- *
- * If Foo inherits from trackable then both the derived reference and the
- * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
- * reference without doing an implicit conversion. To retrieve the derived reference
- * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
- * reference (so that you can call visit_each() on it), you use visit().
- *
- * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
- * derived reference.
- *
- * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values, 
- * and, with mem_fun(), the reference to the handling object.
- *
- * - @e T_type The type of the reference.
- */
-template <class T_type,
-          bool I_derives_trackable =
-            is_base_and_derived<trackable, T_type>::value>
-class volatile_limit_reference
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  volatile_limit_reference(T_type& _A_target)
-    : visited(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const T_type& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline volatile T_type& invoke() const
-    { return visited; }
-
-private:
-  /** The reference.
-   */
-  T_type& visited;
-};
-
-/** volatile_limit_reference object for a class that derives from trackable.
- * - @e T_type The type of the reference.
- */
-template <class T_type>
-class volatile_limit_reference<T_type, true>
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  volatile_limit_reference(T_type& _A_target)
-    : visited(_A_target),
-      invoked(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const trackable& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline volatile T_type& invoke() const
-    { return invoked; }
-
-private:
-  /** The trackable reference.
-   */
-  trackable& visited;
-
-  /** The reference.
-   */
-  T_type& invoked;
-};
-
-/** Implementation of visit_each() specialized for the volatile_limit_reference
- * class, to call visit_each() on the entity returned by the volatile_limit_reference's
- * visit() method.
- * - @e T_action The type of functor to invoke.
- * - @e T_type The type of the reference.
- * @param _A_action The functor to invoke.
- * @param _A_argument The visited instance.
- */
-template <class T_action, class T_type, bool I_derives_trackable>
-void
-visit_each(const T_action& _A_action,
-           const volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
-{
-  visit_each(_A_action, _A_target.visit());
-}
-
-
-/** A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
- * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
- * sigc::trackable reference instead of the derived reference. This avoids use of
- * a reference to the derived type when the derived destructor has run. That can be
- * a problem when using virtual inheritance.
- *
- * If Foo inherits from trackable then both the derived reference and the
- * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
- * reference without doing an implicit conversion. To retrieve the derived reference
- * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
- * reference (so that you can call visit_each() on it), you use visit().
- *
- * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
- * derived reference.
- *
- * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values, 
- * and, with mem_fun(), the reference to the handling object.
- *
- * - @e T_type The type of the reference.
- */
-template <class T_type,
-          bool I_derives_trackable =
-            is_base_and_derived<trackable, T_type>::value>
-class const_volatile_limit_reference
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  const_volatile_limit_reference(const T_type& _A_target)
-    : visited(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const T_type& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline const volatile T_type& invoke() const
-    { return visited; }
-
-private:
-  /** The reference.
-   */
-  const T_type& visited;
-};
-
-/** const_volatile_limit_reference object for a class that derives from trackable.
- * - @e T_type The type of the reference.
- */
-template <class T_type>
-class const_volatile_limit_reference<T_type, true>
-{
-public:
-  /** Constructor.
-   * @param _A_target The reference to limit.
-   */
-  const_volatile_limit_reference(const T_type& _A_target)
-    : visited(_A_target),
-      invoked(_A_target)
-    {}
-
-  /** Retrieve the entity to visit for visit_each().
-   * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
-   * @return The reference.
-   */
-  inline const trackable& visit() const
-    { return visited; }
-
-  /** Retrieve the reference.
-   * This is always a reference to the derived instance.
-   * @return The reference.
-   */
-  inline const volatile T_type& invoke() const
-    { return invoked; }
-
-private:
-  /** The trackable reference.
-   */
-  const trackable& visited;
-
-  /** The reference.
-   */
-  const T_type& invoked;
-};
-
-/** Implementation of visit_each() specialized for the const_volatile_limit_reference
- * class, to call visit_each() on the entity returned by the const_volatile_limit_reference's
- * visit() method.
- * - @e T_action The type of functor to invoke.
- * - @e T_type The type of the reference.
- * @param _A_action The functor to invoke.
- * @param _A_argument The visited instance.
- */
-template <class T_action, class T_type, bool I_derives_trackable>
-void
-visit_each(const T_action& _A_action,
-           const const_volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
-{
-  visit_each(_A_action, _A_target.visit());
-}
-
-
-} /* namespace sigc */
-
-
-#endif /* _SIGC_MACROS_LIMIT_REFERENCEHM4_ */
diff --git a/libs/sigc++2/sigc++/reference_wrapper.h b/libs/sigc++2/sigc++/reference_wrapper.h
index 5a57e91679..436e02f9bb 100644
--- a/libs/sigc++2/sigc++/reference_wrapper.h
+++ b/libs/sigc++2/sigc++/reference_wrapper.h
@@ -98,6 +98,14 @@ struct unwrap_reference<const_reference_wrapper<T_type> >
 };
 
 template <class T_type>
+T_type& unwrap(T_type& v)
+{ return v; }
+
+template <class T_type>
+const T_type& unwrap(const T_type& v)
+{ return v; }
+
+template <class T_type>
 T_type& unwrap(const reference_wrapper<T_type>& v)
 { return v; }
 
diff --git a/libs/sigc++2/sigc++/retype.h b/libs/sigc++2/sigc++/retype.h
index e81040a09c..069313573b 100644
--- a/libs/sigc++2/sigc++/retype.h
+++ b/libs/sigc++2/sigc++/retype.h
@@ -23,98 +23,98 @@ struct retype_slot_functor
   template <class T_arg1>
   inline T_return operator()(T_arg1 _A_a1)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
-        (static_cast<T_type1>(_A_a1)));
+        ((T_type1)_A_a1));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   inline T_return sun_forte_workaround(T_arg1 _A_a1)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
-        (static_cast<T_type1>(_A_a1)));
+        ((T_type1)_A_a1));
     }
   #endif
   
   template <class T_arg1,class T_arg2>
   inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
+        ((T_type1)_A_a1,(T_type2)_A_a2));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
+        ((T_type1)_A_a1,(T_type2)_A_a2));
     }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3>
   inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
     }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
     }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
     }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
     }
   #endif
   
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
     }
   #endif
   
@@ -144,98 +144,98 @@ struct retype_slot_functor<T_functor, void, T_type1,T_type2,T_type3,T_type4,T_ty
   template <class T_arg1>
   inline void operator()(T_arg1 _A_a1)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
-        (static_cast<T_type1>(_A_a1)));
+        ((T_type1)_A_a1));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1>
   inline void sun_forte_workaround(T_arg1 _A_a1)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
-        (static_cast<T_type1>(_A_a1)));
+        ((T_type1)_A_a1));
     }
   #endif
     
   template <class T_arg1,class T_arg2>
   inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
+        ((T_type1)_A_a1,(T_type2)_A_a2));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2>
   inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
+        ((T_type1)_A_a1,(T_type2)_A_a2));
     }
   #endif
     
   template <class T_arg1,class T_arg2,class T_arg3>
   inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3>
   inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
     }
   #endif
     
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
   inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
     }
   #endif
     
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
   inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
     }
   #endif
     
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
   inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
     }
   #endif
     
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
     }
 
   #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
   template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
   inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
     { T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
-        (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
+        ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
     }
   #endif
     
@@ -250,7 +250,6 @@ void retype_slot_functor<T_functor, void, T_type1,T_type2,T_type3,T_type4,T_type
   { this->functor_(); }
 
 
-//template specialization of visit_each<>(action, functor):
 template <class T_action, class T_functor, class T_return, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
 void visit_each(const T_action& _A_action,
                 const retype_slot_functor<T_functor, T_return, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_target)
diff --git a/libs/sigc++2/sigc++/signal.h b/libs/sigc++2/sigc++/signal.h
index f97eb36143..9c4e35442a 100644
--- a/libs/sigc++2/sigc++/signal.h
+++ b/libs/sigc++2/sigc++/signal.h
@@ -11,13 +11,11 @@
 #include <sigc++/functors/slot.h>
 #include <sigc++/functors/mem_fun.h>
 
-//SIGC_TYPEDEF_REDEFINE_ALLOWED:
-// TODO: This should have its own test, but I can not create one that gives the error instead of just a warning. murrayc.
+// TODO: This should have its own test.
 // I have just used this because there is a correlation between these two problems.
 #ifdef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
-  //Compilers, such as older versions of SUN Forte C++, that do not allow this also often
+  //Compilers, such as SUN Forte C++, that do not allow this also often
   //do not allow a typedef to have the same name as a class in the typedef's definition.
-  //For Sun Forte CC 5.7 (SUN Workshop 10), comment this out to fix the build.
   #define SIGC_TYPEDEF_REDEFINE_ALLOWED 1
 #endif
 
@@ -73,7 +71,7 @@ struct slot_iterator
       return *this;
     }
 
-  slot_iterator operator--(int)
+  slot_iterator& operator--(int)
     {
       slot_iterator __tmp(*this);
       --i_;
@@ -139,7 +137,7 @@ struct slot_const_iterator
       return *this;
     }
 
-  slot_const_iterator operator--(int)
+  slot_const_iterator& operator--(int)
     {
       slot_const_iterator __tmp(*this);
       --i_;
@@ -173,20 +171,8 @@ struct slot_list
 
   typedef slot_iterator<slot_type>              iterator;
   typedef slot_const_iterator<slot_type>        const_iterator;
-  
-  #ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
   typedef std::reverse_iterator<iterator>       reverse_iterator;
   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  #else
-  typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
-                                int, int&, int*, ptrdiff_t> reverse_iterator;
-
-  typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
-                                int, const int&, const int*, ptrdiff_t> const_reverse_iterator;
-  #endif /* SIGC_HAVE_SUN_REVERSE_ITERATOR */
-
-
-
 
   slot_list()
     : list_(0) {}
@@ -321,7 +307,7 @@ struct slot_iterator_buf
       return *this;
     }
 
-  slot_iterator_buf operator--(int)
+  slot_iterator_buf& operator--(int)
     {
       slot_iterator_buf __tmp(*this);
       --i_;
@@ -397,7 +383,7 @@ struct slot_iterator_buf<T_emitter, void>
       return *this;
     }
 
-  slot_iterator_buf operator--(int)
+  slot_iterator_buf& operator--(int)
     {
       slot_iterator_buf __tmp(*this);
       --i_;
@@ -453,11 +439,10 @@ struct signal_emit0
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self ;
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
 };
@@ -483,32 +468,21 @@ struct signal_emit0<T_return, nil_>
    */
   static result_type emit(signal_impl* impl)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
+        }
       return r_;
     }
 };
@@ -535,9 +509,8 @@ struct signal_emit0<void, nil_>
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -590,11 +563,10 @@ struct signal_emit1
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self (_A_a1);
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
   typename type_trait<T_arg1>::take _A_a1_;
@@ -623,32 +595,21 @@ struct signal_emit1<T_return, T_arg1, nil_>
    */
   static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+        }
       return r_;
     }
 };
@@ -677,9 +638,8 @@ struct signal_emit1<void, T_arg1, nil_>
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -733,11 +693,10 @@ struct signal_emit2
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self (_A_a1,_A_a2);
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
   typename type_trait<T_arg1>::take _A_a1_;
@@ -768,32 +727,21 @@ struct signal_emit2<T_return, T_arg1,T_arg2, nil_>
    */
   static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
+        }
       return r_;
     }
 };
@@ -823,9 +771,8 @@ struct signal_emit2<void, T_arg1,T_arg2, nil_>
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -880,11 +827,10 @@ struct signal_emit3
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self (_A_a1,_A_a2,_A_a3);
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
   typename type_trait<T_arg1>::take _A_a1_;
@@ -917,32 +863,21 @@ struct signal_emit3<T_return, T_arg1,T_arg2,T_arg3, nil_>
    */
   static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
+        }
       return r_;
     }
 };
@@ -973,9 +908,8 @@ struct signal_emit3<void, T_arg1,T_arg2,T_arg3, nil_>
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -1031,11 +965,10 @@ struct signal_emit4
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self (_A_a1,_A_a2,_A_a3,_A_a4);
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
   typename type_trait<T_arg1>::take _A_a1_;
@@ -1070,32 +1003,21 @@ struct signal_emit4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil_>
    */
   static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
+        }
       return r_;
     }
 };
@@ -1127,9 +1049,8 @@ struct signal_emit4<void, T_arg1,T_arg2,T_arg3,T_arg4, nil_>
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -1186,11 +1107,10 @@ struct signal_emit5
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
   typename type_trait<T_arg1>::take _A_a1_;
@@ -1227,32 +1147,21 @@ struct signal_emit5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil_>
    */
   static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+        }
       return r_;
     }
 };
@@ -1285,9 +1194,8 @@ struct signal_emit5<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil_>
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -1345,11 +1253,10 @@ struct signal_emit6
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
   typename type_trait<T_arg1>::take _A_a1_;
@@ -1388,32 +1295,21 @@ struct signal_emit6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil_>
    */
   static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+        }
       return r_;
     }
 };
@@ -1447,9 +1343,8 @@ struct signal_emit6<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil_>
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -1508,11 +1403,10 @@ struct signal_emit7
         return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
 
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
       self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
-      return accumulator(slot_iterator_buf_type(slots.begin(), &self),
-                         slot_iterator_buf_type(slots.end(), &self));
+      return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
+                         slot_iterator_buf_type(impl->slots_.end(), &self));
     }
   
   typename type_trait<T_arg1>::take _A_a1_;
@@ -1553,32 +1447,21 @@ struct signal_emit7<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7,
    */
   static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7)
     {
-      if (!impl || impl->slots_.empty())
-        return T_return();
-        
+      if (!impl || impl->slots_.empty()) return T_return();
+      iterator_type it = impl->slots_.begin();
+      for (; it != impl->slots_.end(); ++it)
+        if (!it->empty() && !it->blocked()) break;
+      if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
       signal_exec exec(impl);
-      T_return r_ = T_return(); 
-      
-      //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
-      //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
-      { 
-        temp_slot_list slots(impl->slots_);
-        iterator_type it = slots.begin();
-        for (; it != slots.end(); ++it)
-          if (!it->empty() && !it->blocked()) break;
-          
-        if (it == slots.end())
-          return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-  
-        r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
-        for (++it; it != slots.end(); ++it)
-          {
-            if (it->empty() || it->blocked())
-              continue;
-            r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
-          }
-      }
-      
+
+      T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+      for (++it; it != impl->slots_.end(); ++it)
+        {
+          if (it->empty() || it->blocked())
+            continue;
+          r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+        }
       return r_;
     }
 };
@@ -1613,9 +1496,8 @@ struct signal_emit7<void, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7, nil_
     {
       if (!impl || impl->slots_.empty()) return;
       signal_exec exec(impl);
-      temp_slot_list slots(impl->slots_);
 
-      for (iterator_type it = slots.begin(); it != slots.end(); ++it)
+      for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
         {
           if (it->empty() || it->blocked())
             continue;
@@ -2658,14 +2540,13 @@ public:
 };
 
 
-
 /** Convenience wrapper for the numbered sigc::signal0 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::signal
  * template for 0 argument(s).
  */
 template <class T_return>
-class signal <T_return, nil_,nil_,nil_,nil_,nil_,nil_,nil_>
+class signal <T_return>
   : public signal0<T_return, nil_>
 {
 public:
@@ -2689,14 +2570,13 @@ public:
     : signal0<T_return, nil_>(src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::signal1 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::signal
  * template for 1 argument(s).
  */
 template <class T_return, class T_arg1>
-class signal <T_return, T_arg1, nil_,nil_,nil_,nil_,nil_,nil_>
+class signal <T_return, T_arg1>
   : public signal1<T_return, T_arg1, nil_>
 {
 public:
@@ -2720,14 +2600,13 @@ public:
     : signal1<T_return, T_arg1, nil_>(src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::signal2 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::signal
  * template for 2 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2>
-class signal <T_return, T_arg1,T_arg2, nil_,nil_,nil_,nil_,nil_>
+class signal <T_return, T_arg1,T_arg2>
   : public signal2<T_return, T_arg1,T_arg2, nil_>
 {
 public:
@@ -2751,14 +2630,13 @@ public:
     : signal2<T_return, T_arg1,T_arg2, nil_>(src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::signal3 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::signal
  * template for 3 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3>
-class signal <T_return, T_arg1,T_arg2,T_arg3, nil_,nil_,nil_,nil_>
+class signal <T_return, T_arg1,T_arg2,T_arg3>
   : public signal3<T_return, T_arg1,T_arg2,T_arg3, nil_>
 {
 public:
@@ -2782,14 +2660,13 @@ public:
     : signal3<T_return, T_arg1,T_arg2,T_arg3, nil_>(src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::signal4 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::signal
  * template for 4 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil_,nil_,nil_>
+class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4>
   : public signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil_>
 {
 public:
@@ -2813,14 +2690,13 @@ public:
     : signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil_>(src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::signal5 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::signal
  * template for 5 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil_,nil_>
+class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
   : public signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil_>
 {
 public:
@@ -2844,14 +2720,13 @@ public:
     : signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil_>(src) {}
 };
 
-
 /** Convenience wrapper for the numbered sigc::signal6 template.
  * See the base class for useful methods.
  * This is the template specialization of the unnumbered sigc::signal
  * template for 6 argument(s).
  */
 template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil_>
+class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
   : public signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil_>
 {
 public:
diff --git a/libs/sigc++2/sigc++/signal_base.cc b/libs/sigc++2/sigc++/signal_base.cc
index e22017f10b..568cf061c8 100644
--- a/libs/sigc++2/sigc++/signal_base.cc
+++ b/libs/sigc++2/sigc++/signal_base.cc
@@ -68,7 +68,6 @@ signal_impl::iterator_type signal_impl::insert(signal_impl::iterator_type i, con
 
 void signal_impl::sweep()
 {
-  deferred_ = false;
   iterator_type i = slots_.begin();
   while (i != slots_.end())
     if ((*i).empty())
@@ -79,7 +78,7 @@ void signal_impl::sweep()
 
 void* signal_impl::notify(void* d)
 {
-  signal_impl* self = reinterpret_cast<signal_impl*>(d);
+  signal_impl* self = (signal_impl*)d;
   if (self->exec_count_ == 0)
     self->sweep();
   else                       // This is occuring during signal emission.
diff --git a/libs/sigc++2/sigc++/signal_base.h b/libs/sigc++2/sigc++/signal_base.h
index 582a8f4943..3af33d3e99 100644
--- a/libs/sigc++2/sigc++/signal_base.h
+++ b/libs/sigc++2/sigc++/signal_base.h
@@ -44,9 +44,8 @@ namespace internal
 struct SIGC_API signal_impl
 {
   typedef size_t size_type;
-  typedef std::list<slot_base> slot_list;
-  typedef slot_list::iterator       iterator_type;
-  typedef slot_list::const_iterator const_iterator_type;
+  typedef std::list<slot_base>::iterator       iterator_type;
+  typedef std::list<slot_base>::const_iterator const_iterator_type;
 
   signal_impl();
 
@@ -161,40 +160,6 @@ struct SIGC_API signal_exec
     { sig_->unreference_exec(); }
 };
 
-/** Temporary slot list used during signal emission.
- *  Through evolution this class is slightly misnamed.  It is now
- *  an index into the slot_list passed into it.  It simply keeps track
- *  of where the end of this list was at construction, and pretends that's
- *  the end of your list.  This way you may connect during emittion without
- *  inadvertently entering an infinite loop, as well as make other
- *  modifications to the slot_list at your own risk.
- */
-struct temp_slot_list
-{
-  typedef signal_impl::slot_list slot_list;
-  typedef signal_impl::iterator_type iterator;
-  typedef signal_impl::const_iterator_type const_iterator;
-
-  temp_slot_list(slot_list &slots) : slots_(slots)
-  {
-    placeholder = slots_.insert(slots_.end(), slot_base());
-  }
-
-  ~temp_slot_list()
-  {
-    slots_.erase(placeholder);
-  }
-
-  iterator begin() { return slots_.begin(); }
-  iterator end() { return placeholder; }
-  const_iterator begin() const { return slots_.begin(); }
-  const_iterator end() const { return placeholder; }
-
-private:
-  slot_list &slots_;
-  slot_list::iterator placeholder;
-};
-  
 } /* namespace internal */
 
 
@@ -263,16 +228,13 @@ struct SIGC_API signal_base : public trackable
 protected:
   typedef internal::signal_impl::iterator_type iterator_type;
 
-  /** Adds a slot at the end of the list of slots.
-   * With connect(), slots can also be added during signal emission.
-   * In this case, they won't be executed until the next emission occurs.
+  /** Adds a slot at the bottom of the list of slots.
    * @param slot_ The slot to add to the list of slots.
    * @return An iterator pointing to the new slot in the list.
    */
   iterator_type connect(const slot_base& slot_);
 
   /** Adds a slot at the given position into the list of slots.
-   * Note that this function does not work during signal emission!
    * @param i An iterator indicating the position where @e slot_ should be inserted.
    * @param slot_ The slot to add to the list of slots.
    * @return An iterator pointing to the new slot in the list.
@@ -280,7 +242,6 @@ protected:
   iterator_type insert(iterator_type i, const slot_base& slot_);
 
   /** Removes the slot at the given position from the list of slots.
-   * Note that this function does not work during signal emission!
    * @param i An iterator pointing to the slot to be removed.
    * @return An iterator pointing to the slot in the list after the one removed.
    */
diff --git a/libs/sigc++2/sigc++/trackable.cc b/libs/sigc++2/sigc++/trackable.cc
index a4f1f54e18..46e2592ffb 100644
--- a/libs/sigc++2/sigc++/trackable.cc
+++ b/libs/sigc++2/sigc++/trackable.cc
@@ -20,9 +20,6 @@
 
 #include <sigc++/trackable.h>
 #include <iostream>
-
-SIGC_USING_STD(ostream)
-
 using namespace std;
 
 namespace sigc
diff --git a/libs/sigc++2/sigc++/type_traits.h b/libs/sigc++2/sigc++/type_traits.h
index b2c1a7eb2d..c6d6dbbc81 100644
--- a/libs/sigc++2/sigc++/type_traits.h
+++ b/libs/sigc++2/sigc++/type_traits.h
@@ -19,8 +19,7 @@
 #ifndef _SIGC_TYPE_TRAIT_H_
 #define _SIGC_TYPE_TRAIT_H_
 
-#include <sigc++config.h> //To get SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
-
+#include <sigc++/reference_wrapper.h>
 
 namespace sigc {
 
@@ -60,6 +59,24 @@ struct type_trait<const T_type&>
   typedef const T_type* pointer;
 };
 
+template <class T_type>
+struct type_trait<reference_wrapper<T_type> >
+{
+  typedef T_type  type;
+  typedef T_type& pass;
+  typedef T_type& take;
+  typedef T_type* pointer;
+};
+
+template <class T_type>
+struct type_trait<const_reference_wrapper<T_type> >
+{
+  typedef T_type  type;
+  typedef T_type& pass;
+  typedef const T_type& take;
+  typedef T_type* pointer;
+};
+
 template<>
 struct type_trait<void>
 {
@@ -70,27 +87,9 @@ struct type_trait<void>
 };
 
 
-// From Esa Pulkkin:
-/**
+/** From Esa Pulkkin:
  * Compile-time determination of base-class relationship in C++
  * (adapted to match the syntax of boost's type_traits library).
- *
- * Use this to provide a template specialization for a set of types.
- * For instance,
- *
- * template < class T_thing, bool Tval_derives_from_something = sigc::is_base_and_derived<Something, T_thing>::value >
- * class TheTemplate
- * {
- *   //Standard implementation.
- * }
- *
- * //Specialization for T_things that derive from Something (Tval_derives_from_something is true)
- * template <class T_thing>
- * class TheTemplate<T_thing, true>
- * {
- *   T_thing thing;
-     thing.method_that_is_in_something();
- * }
  */
 template <class T_base, class T_derived>
 struct is_base_and_derived
@@ -100,40 +99,15 @@ private:
     char memory[64];
   };
 
-#ifndef SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
-
-  //Allow the internal inner class to access the other (big) inner
-  //class.  The Tru64 compiler needs this. murrayc.
-  friend struct internal_class;
-
-  //Certain compilers, notably GCC 3.2, require these functions to be inside an inner class.
-  struct internal_class
-  {
+  struct test {
     static big  is_base_class_(...);
     static char is_base_class_(typename type_trait<T_base>::pointer);
   };
 
 public:
   static const bool value =
-    sizeof(internal_class::is_base_class_(reinterpret_cast<typename type_trait<T_derived>::pointer>(0))) ==
+    sizeof(test::is_base_class_((typename type_trait<T_derived>::pointer)0)) ==
     sizeof(char);
-
-#else //SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
-
-  //The AIX xlC compiler does not like these 2 functions being in the inner class.
-  //It says "The incomplete type "test" must not be used as a qualifier.
-  //It does not seem necessary anyway. murrayc.
-  static big  is_base_class_(...);
-  static char is_base_class_(typename type_trait<T_base>::pointer);
-
-public:
-  static const bool value =
-    sizeof(is_base_class_(reinterpret_cast<typename type_trait<T_derived>::pointer>(0))) ==
-    sizeof(char);
-
-#endif //SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
-
-  void avoid_gcc3_warning_(); //Not implemented. g++ 3.3.5 (but not 3.3.4, and not 3.4) warn that there are no public methods, even though there is a public variable.
 };
 
 template <class T_base>
diff --git a/libs/sigc++2/sigc++/visit_each.h b/libs/sigc++2/sigc++/visit_each.h
index cff27ba28b..7b7978531f 100644
--- a/libs/sigc++2/sigc++/visit_each.h
+++ b/libs/sigc++2/sigc++/visit_each.h
@@ -26,83 +26,52 @@ namespace sigc {
 
 namespace internal {
 
-//This should really be an inner class of limit_derived_target, without the T_limit template type,
-//But the SUN CC 5.7 (not earlier versions) compiler finds it ambiguous when we specify a particular specialization of it.
-//and does not seem to allow us to tell it explicitly that it's an inner class.
-template <bool I_derived, class T_type, class T_limit>
-struct with_type;
-
-//Specialization for I_derived = false
-template <class T_type, class T_limit> struct
-with_type<false, T_type, T_limit>
-{
-  static void execute_(const T_type&, const T_limit&) {}
-};
-
-//Specialization for I_derived = true
-template <class T_type, class T_limit>
-struct with_type<true, T_type, T_limit>
-{
-  static void execute_(const T_type& _A_type, const T_limit& _A_action)
-  { _A_action.action_(_A_type); }
-};
-
-
 /// Helper struct for visit_each_type().
 template <class T_target, class T_action>
 struct limit_derived_target
 {
   typedef limit_derived_target<T_target, T_action> T_self;
 
- 
-  template <class T_type>
-  void operator()(const T_type& _A_type) const
-  {
-    with_type<is_base_and_derived<T_target, T_type>::value, T_type, T_self>::execute_(_A_type, *this);
-  }
+  template <bool I_derived, class T_type> struct with_type;
 
-  limit_derived_target(const T_action& _A_action)
-  : action_(_A_action)
-  {}
+  template <class T_type> struct with_type<false,T_type>
+  { static void execute_(const T_type&, const T_self&) {} };
 
-  T_action action_;
-};
+  template <class T_type> struct with_type<true,T_type>
+  { static void execute_(const T_type& _A_type, const T_self& _A_action)
+      { _A_action.action_(_A_type); }
+  };
 
-// Specialization for T_target pointer types, to provide a slightly different execute_() implementation.
-
-template <bool I_derived, class T_type, class T_limit>
-struct with_type_pointer;
+  template <class T_type>
+  void operator()(const T_type& _A_type) const
+  { with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
 
-//Specialization for I_derived = false
-template <class T_type, class T_limit>
-struct with_type_pointer<false, T_type, T_limit>
-{
- static void execute_(const T_type&, const T_limit&) {}
-};
+  limit_derived_target(const T_action& _A_action): action_(_A_action) {}
 
-//Specialization for I_derived = true
-template <class T_type, class T_limit>
-struct with_type_pointer<true, T_type, T_limit>
-{
-  static void execute_(const T_type& _A_type, const T_limit& _A_action) 
-  { _A_action.action_(&_A_type); }
+  T_action action_;
 };
 
+/// Helper struct for visit_each_type().
 template <class T_target, class T_action>
 struct limit_derived_target<T_target*, T_action>
 {
   typedef limit_derived_target<T_target*, T_action> T_self;
 
+  template <bool I_derived, class T_type> struct with_type;
+
+  template <class T_type> struct with_type<false,T_type>
+  { static void execute_(const T_type&, const T_self&) {} };
+
+  template <class T_type> struct with_type<true,T_type>
+  { static void execute_(const T_type& _A_type, const T_self& _A_action) 
+     { _A_action.action_(&_A_type); }
+  };
 
   template <class T_type>
   void operator()(const T_type& _A_type) const
-  {
-    with_type_pointer<is_base_and_derived<T_target, T_type>::value, T_type, T_self>::execute_(_A_type, *this);
-  }
+  { with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
 
-  limit_derived_target(const T_action& _A_action)
-  : action_(_A_action)
-  {}
+  limit_derived_target(const T_action& _A_action): action_(_A_action) {}
 
   T_action action_;
 };
@@ -151,23 +120,8 @@ void visit_each(const T_action& _A_action, const T_functor& _A_functor)
 template <class T_type, class T_action, class T_functor>
 void visit_each_type(const T_action& _A_action, const T_functor& _A_functor)
 { 
-  typedef internal::limit_derived_target<T_type, T_action> type_limited_action;
-
-  type_limited_action limited_action(_A_action);
-
-  //specifying the types of the template specialization prevents disconnection of bound trackable references (such as with sigc::ref()),
-  //probably because the visit_each<> specializations take various different template types,
-  //in various sequences, and we are probably specifying only a subset of them with this.
-  //
-  //But this is required by the AIX (and maybe IRIX MipsPro  and Tru64) compilers.
-  //I guess that sigc::ref() therefore does not work on those platforms. murrayc
-  //visit_each<type_limited_action, T_functor>(limited_action, _A_functor);
-
-  //g++ (even slightly old ones) is our primary platform, so we could use the non-crashing version. 
-  //However, the expliict version also fixes a crash in a slightl more common case: http://bugzilla.gnome.org/show_bug.cgi?id=169225
-  //Users (and distributors) of libsigc++ on AIX (and maybe IRIX MipsPro  and Tru64) do 
-  //need to use the version above instead, to allow compilation.
-  visit_each(limited_action, _A_functor);
+  internal::limit_derived_target<T_type,T_action> limited_action(_A_action);
+  visit_each(limited_action,_A_functor);
 }
 
 } /* namespace sigc */
diff --git a/libs/sigc++2/sigc++config.h.in b/libs/sigc++2/sigc++config.h.in
index 1cd8c3e2e0..357873fae6 100644
--- a/libs/sigc++2/sigc++config.h.in
+++ b/libs/sigc++2/sigc++config.h.in
@@ -1,80 +1,10 @@
+/* sigc++config.h.in. (Generated manually.) */
 
-#ifndef _SIGCXX_CONFIG_H
-#define _SIGCXX_CONFIG_H
+/* configure checks */
+#undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+#undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
 
-// Detect common platforms
-#if defined(_WIN32)
-  // Win32 compilers have a lot of variation
-  #if defined(_MSC_VER)
-    #define SIGC_MSC
-    #define SIGC_WIN32
-    #define SIGC_DLL
-  #elif defined(__CYGWIN__)
-    #define SIGC_CONFIGURE
-  #elif defined(__MINGW32__)
-    #define SIGC_WIN32
-    #define SIGC_CONFIGURE
-  #else
-    //The Tru64 compiler complains about this "unrecognized preprocessing directive", but it should never get this far anyway.
-    //#warning "libsigc++ config: Unknown win32 architecture (send me gcc --dumpspecs or equiv)"
-  #endif
-#else
-  #define SIGC_CONFIGURE
-#endif /* _WIN32 */
-
-#ifdef SIGC_CONFIGURE
-  // configure checks
-  #undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
-  #undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
-  #undef SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
-
-  #undef SIGC_HAVE_NAMESPACE_STD
-  #undef SIGC_HAVE_SUN_REVERSE_ITERATOR
-  #undef SIGC_TYPEDEF_REDEFINE_ALLOWED
-
-  // platform specific macros
-  // #define LIBSIGC_DISABLE_DEPRECATED
-  // #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY 
-#endif /* SIGC_CONFIGURE */
-
-#ifdef SIGC_MSC
-
-  // MS VC7 Warning 4251 says that the classes to any member objects in an
-  // exported class must be also be exported.  Some of the libsigc++
-  // template classes contain std::list members.  MS KB article 168958 says
-  // that it's not possible to export a std::list instantiation due to some
-  // wacky class nesting issues, so our only options are to ignore the
-  // warning or to modify libsigc++ to remove the std::list dependency.
-  // AFAICT, the std::list members are used internally by the library code
-  // and don't need to be used from the outside, and ignoring the warning
-  // seems to have no adverse effects, so that seems like a good enough
-  // solution for now.
-  //
-  #pragma warning(disable:4251)
-
-  #define SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
-  #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY // To keep ABI compatibility
-  #define SIGC_HAVE_NAMESPACE_STD 1
-
-#endif /* SIGC_MSC */
-
-//Put things in the std namespace, if they should be there.
-#ifndef SIGC_HAVE_NAMESPACE_STD
-  # define SIGC_USING_STD(Symbol) namespace std { using ::Symbol; }
-#else
-  #  define SIGC_USING_STD(Symbol) /* empty */
-#endif
-
-#ifdef SIGC_DLL
-  #if defined(SIGC_BUILD) && defined(_WINDLL)
-    #define SIGC_API __declspec(dllexport) 
-  #elif !defined(SIGC_BUILD)
-    #define SIGC_API __declspec(dllimport)
-  #else
-    #define SIGC_API
-  #endif /* SIGC_BUILD - _WINDLL */
-#else
-  #define SIGC_API
-#endif /* SIGC_DLL */
-
-#endif /* _SIGCXX_CONFIG_H */
+/* platform specific macros */
+// #define LIBSIGC_DISABLE_DEPRECATED
+// #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY // only defined for MSVC to keep ABI compatibility
+#define SIGC_API
diff --git a/libs/surfaces/control_protocol/basic_ui.cc b/libs/surfaces/control_protocol/basic_ui.cc
index 2f5a4efada..44445192be 100644
--- a/libs/surfaces/control_protocol/basic_ui.cc
+++ b/libs/surfaces/control_protocol/basic_ui.cc
@@ -28,6 +28,7 @@
 #include "i18n.h"
 
 using namespace ARDOUR;
+using ARDOUR::nframes_t;
 
 BasicUI::BasicUI (Session& s)
 	: session (&s)
diff --git a/libs/surfaces/control_protocol/control_protocol.cc b/libs/surfaces/control_protocol/control_protocol.cc
index 8456654f20..708373e3bc 100644
--- a/libs/surfaces/control_protocol/control_protocol.cc
+++ b/libs/surfaces/control_protocol/control_protocol.cc
@@ -21,7 +21,7 @@
 #include <ardour/session.h>
 #include <ardour/route.h>
 #include <ardour/audio_track.h>
-
+#include <ardour/meter.h>
 #include <control_protocol/control_protocol.h>
 
 using namespace ARDOUR;
@@ -259,7 +259,7 @@ ControlProtocol::route_get_peak_input_power (uint32_t table_index, uint32_t whic
 		return 0.0f;
 	}
 
-	return r->peak_input_power (which_input);
+	return r->peak_meter().peak_power (which_input);
 }
 
 
diff --git a/libs/surfaces/generic_midi/generic_midi_control_protocol.cc b/libs/surfaces/generic_midi/generic_midi_control_protocol.cc
index 4bbf3745c6..3906b53e36 100644
--- a/libs/surfaces/generic_midi/generic_midi_control_protocol.cc
+++ b/libs/surfaces/generic_midi/generic_midi_control_protocol.cc
@@ -17,6 +17,9 @@
 
 */
 
+#define __STDC_FORMAT_MACROS 1
+#include <stdint.h>
+
 #include <algorithm>
 
 #include <pbd/error.h>
@@ -114,8 +117,9 @@ GenericMidiControlProtocol::_send_feedback ()
 	if (end == buf) {
 		return;
 	} 
-	
-	_port->write (buf, (int32_t) (end - buf));
+
+	// FIXME
+	//_port->write (buf, (int32_t) (end - buf));
 }
 
 bool
diff --git a/libs/surfaces/generic_midi/midicontrollable.cc b/libs/surfaces/generic_midi/midicontrollable.cc
index 1f00e58167..7bf730b0f5 100644
--- a/libs/surfaces/generic_midi/midicontrollable.cc
+++ b/libs/surfaces/generic_midi/midicontrollable.cc
@@ -303,7 +303,7 @@ MIDIControllable::send_feedback ()
 	msg[1] = control_additional;
 	msg[2] = (byte) (controllable.get_value() * 127.0f);
 
-	_port.write (msg, 3);
+	//_port.write (msg, 3);
 }
 
 MIDI::byte*
diff --git a/libs/surfaces/mackie/surface_port.cc b/libs/surfaces/mackie/surface_port.cc
index f0cdbdbe98..8aa1be7fe9 100644
--- a/libs/surfaces/mackie/surface_port.cc
+++ b/libs/surfaces/mackie/surface_port.cc
@@ -79,7 +79,7 @@ MidiByteArray SurfacePort::read()
 	if ( !active() ) return retval;
 	
 	// read port and copy to return value
-	int nread = port().read( buf, sizeof (buf) );
+	int nread = port().read( buf, sizeof (buf), 0 );
 
 	if (nread >= 0) {
 		retval.copy( nread, buf );
@@ -116,7 +116,7 @@ void SurfacePort::write( const MidiByteArray & mba )
 	Glib::RecMutex::Lock lock( _rwlock );
 	if ( !active() ) return;
 
-	int count = port().write( mba.bytes().get(), mba.size() );
+	int count = port().write( mba.bytes().get(), mba.size(), 0 );
 	if ( count != (int)mba.size() )
 	{
 		if ( errno != EAGAIN )